cmdparser.h

00001 /****************************************************************************
00002 ** $Id: cmdparser.h,v 1.10 2006/03/03 13:11:04 red75 Exp $
00003 **
00004 ** Trade equipment common portable library project
00005 **
00006 ** Copyright (C) 1999-2006 Leader InfoTech.  All rights reserved.
00007 **
00008 ** This file is part of the Library of the Ananas
00009 ** automation accounting system.
00010 **
00011 ** This file may be distributed and/or modified under the terms of the
00012 ** GNU General Public License version 2 as published by the Free Software
00013 ** Foundation and appearing in the file LICENSE.GPL included in the
00014 ** packaging of this file.
00015 **
00016 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
00017 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
00018 **
00019 ** See http://www.leaderit.ru/ or email sales@leaderit.ru
00020 **
00021 ** Contact org@leaderit.ru if any conditions of this licensing are
00022 ** not clear to you.
00023 **
00024 **********************************************************************/
00025 
00026 #ifndef _CMDPARSER_H_
00027 #define _CMDPARSER_H_
00028 
00029 #include "teglobal.h"
00030 #include <qstring.h>
00031 #include <qstringlist.h>
00032 #include <qpair.h>
00033 #include <qtextcodec.h>
00034 #include <qvariant.h>
00035 #include <qvaluevector.h>
00036 #include "conv.h"
00037 
00038 // This class is intended to parse command lines and to handle different encodings,
00039 // along with call forwarding.
00040 
00041 LIB_TEMPLATE_EXTERN template struct LIB_EXPORT QPair<QString,int>;
00042 LIB_TEMPLATE_EXTERN template class LIB_EXPORT QMap<QPair<QString,int>,memFunc*>;
00043 LIB_TEMPLATE_EXTERN template class LIB_EXPORT QMap<QPair<QString,int>,memProc*>;
00044 
00045 class LIB_EXPORT ExecEngine
00046 {
00047     QTextCodec * m_pTextCodec;
00048     QString m_error;
00049     QString m_result;
00050     // function name, arity
00051     typedef QPair<QString,int> FuncDesc; 
00052 
00053     // This class maps function description to functor
00054     typedef QMap<FuncDesc,memFunc*> FuncDescToMemFunc;
00055     typedef QMap<FuncDesc,memProc*> FuncDescToMemProc;
00056 
00057     FuncDescToMemFunc m_mapMemFunc;
00058     FuncDescToMemProc m_mapMemProc;
00059 
00060 public:
00061     ExecEngine();
00062     virtual ~ExecEngine();
00063 
00064     int execute(const char * cmd);
00065     int execute(const QString & ucmd);
00066     QString result() const {return m_result;};
00067     QString error() const {return m_error;};
00068     QString help() const; // it returns list of all functions
00069 
00070     void setEncoding(const QString & encoding);
00071     int parse(const char * cmd, QString & func, QValueVector<QVariant> & parms);
00072     int parse(const QString & ucmd, QString & func, QValueVector<QVariant> & parms);
00073 
00074     template <class T, class R>
00075         int addFuncBinding(T * pobj, R (T::*pfunc)(void), const QString & name)
00076     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00077         delete m_mapMemFunc[FuncDesc(name,0)];
00078         m_mapMemFunc[FuncDesc(name,0)]=new memFunc0<T,R>(pobj,pfunc);
00079         return 0;
00080     };
00081 
00082     template <class T, class R>
00083         int addFuncBinding(T * pobj, R (T::*pfunc)(void) const, const QString & name)
00084     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00085         delete m_mapMemFunc[FuncDesc(name,0)];
00086         m_mapMemFunc[FuncDesc(name,0)]=new memFunc0<T,R, ConstFunc0<T,R> >(pobj,pfunc);
00087         return 0;
00088     };
00089 
00090     template <class T, class R, class P1>
00091         int addFuncBinding(T * pobj, R (T::*pfunc)(P1), const QString & name)
00092     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00093         delete m_mapMemFunc[FuncDesc(name,1)];
00094         m_mapMemFunc[FuncDesc(name,1)]=new memFunc1<T,R,P1>(pobj,pfunc);
00095         return 0;
00096     };
00097 
00098     template <class T, class R, class P1>
00099         int addFuncBinding(T * pobj, R (T::*pfunc)(P1) const, const QString & name)
00100     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00101         delete m_mapMemFunc[FuncDesc(name,1)];
00102         m_mapMemFunc[FuncDesc(name,1)]=new memFunc1<T,R,P1, ConstFunc1<T,R,P1> >(pobj,pfunc);
00103         return 0;
00104     };
00105 
00106     template <class T, class R, class P1, class P2>
00107         int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2), const QString & name)
00108     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00109         delete m_mapMemFunc[FuncDesc(name,2)];
00110         m_mapMemFunc[FuncDesc(name,2)]=new memFunc2<T,R,P1,P2>(pobj,pfunc);
00111         return 0;
00112     };
00113 
00114     template <class T, class R, class P1, class P2>
00115         int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2) const, const QString & name)
00116     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00117         delete m_mapMemFunc[FuncDesc(name,2)];
00118         m_mapMemFunc[FuncDesc(name,2)]=new memFunc2<T,R,P1,P2, ConstFunc2<T,R,P1,P2> >(pobj,pfunc);
00119         return 0;
00120     };
00121 
00122     template <class T, class R, class P1, class P2, class P3>
00123         int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3), const QString & name)
00124     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00125         delete m_mapMemFunc[FuncDesc(name,3)];
00126         m_mapMemFunc[FuncDesc(name,3)]=new memFunc3<T,R,P1,P2,P3>(pobj,pfunc);
00127         return 0;
00128     };
00129 
00130     template <class T, class R, class P1, class P2, class P3>
00131         int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3) const, const QString & name)
00132     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00133         delete m_mapMemFunc[FuncDesc(name,3)];
00134         m_mapMemFunc[FuncDesc(name,3)]=new memFunc3<T,R,P1,P2,P3, ConstFunc3<T,R,P1,P2,P3> >(pobj,pfunc);
00135         return 0;
00136     };
00137 
00138     template <class T, class R, class P1, class P2, class P3, class P4>
00139         int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3,P4), const QString & name)
00140     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00141         delete m_mapMemFunc[FuncDesc(name,4)];
00142         m_mapMemFunc[FuncDesc(name,4)]=new memFunc4<T,R,P1,P2,P3,P4>(pobj,pfunc);
00143         return 0;
00144     };
00145 
00146     template <class T, class R, class P1, class P2, class P3, class P4>
00147         int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3,P4) const, const QString & name)
00148     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00149         delete m_mapMemFunc[FuncDesc(name,4)];
00150         m_mapMemFunc[FuncDesc(name,4)]=new memFunc4<T,R,P1,P2,P3,P4, ConstFunc4<T,R,P1,P2,P3,P4> >(pobj,pfunc);
00151         return 0;
00152     };
00153 
00154     template <class T, class R, class P1, class P2, class P3, class P4, class P5>
00155         int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3,P4,P5), const QString & name)
00156     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00157         delete m_mapMemFunc[FuncDesc(name,5)];
00158         m_mapMemFunc[FuncDesc(name,5)]=new memFunc5<T,R,P1,P2,P3,P4,P5>(pobj,pfunc);
00159         return 0;
00160     };
00161 
00162     template <class T, class R, class P1, class P2, class P3, class P4, class P5>
00163         int addFuncBinding(T * pobj, R (T::*pfunc)(P1,P2,P3,P4,P5) const, const QString & name)
00164     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00165         delete m_mapMemFunc[FuncDesc(name,5)];
00166         m_mapMemFunc[FuncDesc(name,5)]=new memFunc5<T,R,P1,P2,P3,P4,P5, ConstFunc5<T,R,P1,P2,P3,P4,P5> >(pobj,pfunc);
00167         return 0;
00168     };
00169 
00170     template <class T, class R>
00171         int addFuncBinding0(T * pobj, typename memFunc0<T,R>::memFunPtr pfunc, const QString & name)
00172     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00173         delete m_mapMemFunc[FuncDesc(name,0)];
00174         m_mapMemFunc[FuncDesc(name,0)]=new memFunc0<T,R>(pobj,pfunc);
00175         return 0;
00176     };
00177 
00178     template <class T, class R, class FuncType >
00179         int addFuncBinding0(T * pobj, typename memFunc0<T,R,FuncType>::memFunPtr pfunc, const QString & name)
00180     { // if there was no value, this string evaluates to 'delete 0', which is acceptable
00181         delete m_mapMemFunc[FuncDesc(name,0)];
00182         m_mapMemFunc[FuncDesc(name,0)]=new memFunc0<T,R,FuncType>(pobj,pfunc);
00183         return 0;
00184     };
00185 
00186     template <class T, class R, class P1>
00187         int addFuncBinding1(T * pobj, typename memFunc1<T,R,P1>::memFunPtr pfunc, const QString & name)
00188     {
00189         delete m_mapMemFunc[FuncDesc(name,1)];
00190         m_mapMemFunc[FuncDesc(name,1)]=new memFunc1<T,R,P1>(pobj,pfunc);
00191         return 0;
00192     };
00193 
00194     template <class T, class R, class P1, class P2>
00195         int addFuncBinding2(T * pobj, typename memFunc2<T,R,P1,P2>::memFunPtr pfunc, const QString & name)
00196     {
00197         delete m_mapMemFunc[FuncDesc(name,2)];
00198         m_mapMemFunc[FuncDesc(name,2)]=new memFunc2<T,R,P1,P2>(pobj,pfunc);
00199         return 0;
00200     };
00201 
00202     template <class T, class R, class P1, class P2, class P3>
00203         int addFuncBinding3(T * pobj, typename memFunc3<T,R,P1,P2,P3>::memFunPtr pfunc, const QString & name)
00204     {
00205         delete m_mapMemFunc[FuncDesc(name,3)];
00206         m_mapMemFunc[FuncDesc(name,3)]=new memFunc3<T,R,P1,P2,P3>(pobj,pfunc);
00207         return 0;
00208     };
00209     template <class T, class R, class P1, class P2, class P3, class P4>
00210         int addFuncBinding4(T * pobj, typename memFunc4<T,R,P1,P2,P3,P4>::memFunPtr pfunc, const QString & name)
00211     {
00212         delete m_mapMemFunc[FuncDesc(name,4)];
00213         m_mapMemFunc[FuncDesc(name,4)]=new memFunc4<T,R,P1,P2,P3,P4>(pobj,pfunc);
00214         return 0;
00215     };
00216 
00217     template <class T, class R, class P1, class P2, class P3, class P4, class P5>
00218         int addFuncBinding5(T * pobj, typename memFunc5<T,R,P1,P2,P3,P4,P5>::memFunPtr pfunc, const QString & name)
00219     {
00220         delete m_mapMemFunc[FuncDesc(name,5)];
00221         m_mapMemFunc[FuncDesc(name,5)]=new memFunc5<T,R,P1,P2,P3,P4,P5>(pobj,pfunc);
00222         return 0;
00223     };
00224 
00225     template <class T, class P1, class P2, class P3, class P4, class P5>
00226         int addProcBinding5(T * pobj, typename memProc5<T,P1,P2,P3,P4,P5>::memProcPtr pfunc, const QString & name)
00227     {
00228         delete m_mapMemProc[FuncDesc(name,5)];
00229         m_mapMemProc[FuncDesc(name,5)]=new memProc5<T,P1,P2,P3,P4,P5>(pobj,pfunc);
00230         return 0;
00231     };
00232 
00233     template <class T, class P1, class P2, class P3, class P4>
00234         int addProcBinding4(T * pobj, typename memProc4<T,P1,P2,P3,P4>::memProcPtr pfunc, const QString & name)
00235     {
00236         delete m_mapMemProc[FuncDesc(name,4)];
00237         m_mapMemProc[FuncDesc(name,4)]=new memProc4<T,P1,P2,P3,P4>(pobj,pfunc);
00238         return 0;
00239     };
00240 
00241     template <class T, class P1, class P2, class P3>
00242         int addProcBinding3(T * pobj, typename memProc3<T,P1,P2,P3>::memProcPtr pfunc, const QString & name)
00243     {
00244         delete m_mapMemProc[FuncDesc(name,3)];
00245         m_mapMemProc[FuncDesc(name,3)]=new memProc3<T,P1,P2,P3>(pobj,pfunc);
00246         return 0;
00247     };
00248 
00249     template <class T, class P1, class P2>
00250         int addProcBinding2(T * pobj, typename memProc2<T,P1,P2>::memProcPtr pfunc, const QString & name)
00251     {
00252         delete m_mapMemProc[FuncDesc(name,2)];
00253         m_mapMemProc[FuncDesc(name,2)]=new memProc2<T,P1,P2>(pobj,pfunc);
00254         return 0;
00255     };
00256 
00257     template <class T, class P1>
00258         int addProcBinding1(T * pobj, typename memProc1<T,P1>::memProcPtr pfunc, const QString & name)
00259     {
00260         delete m_mapMemProc[FuncDesc(name,1)];
00261         m_mapMemProc[FuncDesc(name,1)]=new memProc1<T,P1>(pobj,pfunc);
00262         return 0;
00263     };
00264 
00265     template <class T>
00266         int addProcBinding0(T * pobj, typename memProc0<T>::memProcPtr pfunc, const QString & name)
00267     {
00268         delete m_mapMemProc[FuncDesc(name,0)];
00269         m_mapMemProc[FuncDesc(name,0)]=new memProc0<T>(pobj,pfunc);
00270         return 0;
00271     };
00272 
00273     template <class T, class FT>
00274         int addProcBinding0(T * pobj, typename memProc0<T,FT>::memProcPtr pfunc, const QString & name)
00275     {
00276         delete m_mapMemProc[FuncDesc(name,0)];
00277         m_mapMemProc[FuncDesc(name,0)]=new memProc0<T,FT>(pobj,pfunc);
00278         return 0;
00279     };
00280 };
00281 
00282 // Helper functions, which are intended to simplify function binding code
00283 
00284 /*
00285 template <class T>
00286 int addProcBinding(ExecEngine & ee, T * pObj, void (T::*func)() const, const QString & name)
00287 {
00288         return ee.addProcBinding0<T, ConstProc0<T> >(pObj, func, name);
00289 }
00290 
00291 template <class T>
00292 int addProcBinding(ExecEngine & ee, T * pObj, void (T::*func)(), const QString & name)
00293 {
00294         return ee.addProcBinding0<T>(pObj,func,name);
00295 }
00296 
00297 template <class Ty, class R>
00298 int addFuncBinding(ExecEngine & ee, Ty * pObj, R (Ty::*func)() const, const QString & name)
00299 {
00300         return ee.addFuncBinding0<Ty,R,ConstFunc0<Ty,R> >(pObj,func,name);
00301 }
00302 
00303 template <class T, class R>
00304 int addFuncBinding(ExecEngine & ee, T * pObj, R (T::*func)(), const QString & name)
00305 {
00306         return ee.addFuncBinding0<T,R>(pObj,func,name);
00307 }
00308 
00309 template <class T, class R, class P1>
00310 int addFuncBinding(ExecEngine & ee, T * pObj, R (T::*func)(P1), const QString & name)
00311 {
00312         return ee.addFuncBinding1<T,R,P1>(pObj,func,name);
00313 }
00314 
00315 template <class T, class R, class P1>
00316 int addFuncBinding(ExecEngine & ee, T * pObj, R (T::*func)(P1) const, const QString & name)
00317 {
00318         return ee.addFuncBinding1<T,R,P1,ConstFunc1<T,R,P1> >(pObj,func,name);
00319 }
00320 
00321 template <class T, class R, class P1, class P2>
00322 int addFuncBinding(ExecEngine & ee, T * pObj, R (T::*func)(P1,P2), const QString & name)
00323 {
00324         return ee.addFuncBinding2<T,R,P1,P2>(pObj,func,name);
00325 }
00326 
00327 template <class T, class R, class P1, class P2>
00328 int addFuncBinding(ExecEngine & ee, T * pObj, R (T::*func)(P1,P2) const, const QString & name)
00329 {
00330         return ee.addFuncBinding2<T,R,P1,P2,ConstFunc1<T,R,P1,P2> >(pObj,func,name);
00331 }
00332 */
00333 
00334 #endif

Документация по Общая библиотека для работы с торговым оборудованием.. Последние изменения: Sun Jul 2 23:37:24 2006. Создано системой  doxygen 1.4.7