lib

proxy.h

00001 /***************************************************************************
00002  * proxy.h
00003  * This file is part of the KDE project
00004  * copyright (C)2004-2005 by Sebastian Sauer (mail@dipe.org)
00005  *
00006  * This program is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Library General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2 of the License, or (at your option) any later version.
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013  * Library General Public License for more details.
00014  * You should have received a copy of the GNU Library General Public License
00015  * along with this program; see the file COPYING.  If not, write to
00016  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017  * Boston, MA 02110-1301, USA.
00018  ***************************************************************************/
00019 
00020 #ifndef KROSS_API_PROXY_H
00021 #define KROSS_API_PROXY_H
00022 
00023 #include "../main/krossconfig.h"
00024 #include "object.h"
00025 #include "variant.h"
00026 #include "list.h"
00027 
00028 #include <qstring.h>
00029 
00030 namespace Kross { namespace Api {
00031 
00035     template<class OBJ>
00036     struct ProxyArgTranslator {
00037         OBJ* m_object;
00038         ProxyArgTranslator(Kross::Api::Object* obj) {
00039             m_object = Kross::Api::Object::fromObject<OBJ>(obj);
00040         }
00041         template<typename T>
00042         inline operator T () {
00043             return m_object->operator T();
00044         }
00045     };
00046 
00050     struct ProxyRetTranslator {
00051         template<class RETURNOBJ, typename TYPE>
00052         inline static Object::Ptr cast(TYPE t) {
00053             return RETURNOBJ::toObject(t);
00054         }
00055     };
00056 
00095     template< class INSTANCE, // the objectinstance
00096               typename METHOD, // the method-signature
00097               class RETURNOBJ,// = Kross::Api::Object, // return-value
00098               class ARG1OBJ = Kross::Api::Object, // first parameter-value
00099               class ARG2OBJ = Kross::Api::Object, // second parameter-value
00100               class ARG3OBJ = Kross::Api::Object, // theird parameter-value
00101               class ARG4OBJ = Kross::Api::Object // forth parameter-value
00102     >
00103     class ProxyFunction : public Function
00104     {
00105             template<class PROXYFUNC, typename RETURNTYPE>
00106             friend struct ProxyFunctionCaller;
00107         private:
00109             INSTANCE* m_instance;
00111             const METHOD m_method;
00112 
00114             KSharedPtr<ARG1OBJ> m_defarg1;
00116             KSharedPtr<ARG2OBJ> m_defarg2;
00118             KSharedPtr<ARG3OBJ> m_defarg3;
00120             KSharedPtr<ARG4OBJ> m_defarg4;
00121 
00126             template<class PROXYFUNC, typename RETURNTYPE>
00127             struct ProxyFunctionCaller {
00128                 inline static Object::Ptr exec(PROXYFUNC* self, Kross::Api::Object* arg1, Kross::Api::Object* arg2, Kross::Api::Object* arg3, Kross::Api::Object* arg4) {
00129                     return ProxyRetTranslator::cast<RETURNTYPE>(
00130                         ( (self->m_instance)->*(self->m_method) )( ProxyArgTranslator<ARG1OBJ>(arg1), ProxyArgTranslator<ARG2OBJ>(arg2), ProxyArgTranslator<ARG3OBJ>(arg3), ProxyArgTranslator<ARG4OBJ>(arg4) )
00131                     );
00132                 }
00133             };
00134 
00140             template<class PROXYFUNC>
00141             struct ProxyFunctionCaller<PROXYFUNC, void> {
00142                 inline static Object::Ptr exec(PROXYFUNC* self, Kross::Api::Object* arg1, Kross::Api::Object* arg2, Kross::Api::Object* arg3, Kross::Api::Object* arg4) {
00143                     ( (self->m_instance)->*(self->m_method) )( ProxyArgTranslator<ARG1OBJ>(arg1), ProxyArgTranslator<ARG1OBJ>(arg2), ProxyArgTranslator<ARG3OBJ>(arg3), ProxyArgTranslator<ARG4OBJ>(arg4) );
00144                     return 0; // void return-value
00145                 }
00146             };
00147 
00148         public:
00149 
00157             ProxyFunction(INSTANCE* instance, const METHOD& method, ARG1OBJ* defarg1 = 0, ARG2OBJ* defarg2 = 0, ARG3OBJ* defarg3 = 0, ARG4OBJ* defarg4 = 0)
00158                 : m_instance(instance), m_method(method), m_defarg1(defarg1), m_defarg2(defarg2), m_defarg3(defarg3), m_defarg4(defarg4) {}
00159 
00169             Object::Ptr call(List::Ptr args) {
00170                 return ProxyFunctionCaller<ProxyFunction, RETURNOBJ>::exec(this,
00171                     args->item(0, m_defarg1),
00172                     args->item(1, m_defarg2),
00173                     args->item(2, m_defarg3),
00174                     args->item(3, m_defarg4)
00175                 );
00176             }
00177     };
00178 
00182     template<class INSTANCE, typename METHOD, class RETURNOBJ, class ARG1OBJ, class ARG2OBJ, class ARG3OBJ>
00183     class ProxyFunction<INSTANCE, METHOD, RETURNOBJ, ARG1OBJ, ARG2OBJ, ARG3OBJ> : public Function
00184     {
00185             template<class PROXYFUNC, typename RETURNTYPE>
00186             friend struct ProxyFunctionCaller;
00187         private:
00188             INSTANCE* m_instance;
00189             const METHOD m_method;
00190             KSharedPtr<ARG1OBJ> m_defarg1;
00191             KSharedPtr<ARG2OBJ> m_defarg2;
00192             KSharedPtr<ARG3OBJ> m_defarg3;
00193 
00194             template<class PROXYFUNC, typename RETURNTYPE>
00195             struct ProxyFunctionCaller {
00196                 inline static Object::Ptr exec(PROXYFUNC* self, Kross::Api::Object* arg1, Kross::Api::Object* arg2, Kross::Api::Object* arg3) {
00197                     return ProxyRetTranslator::cast<RETURNTYPE>(
00198                         ( (self->m_instance)->*(self->m_method) )( ProxyArgTranslator<ARG1OBJ>(arg1), ProxyArgTranslator<ARG2OBJ>(arg2), ProxyArgTranslator<ARG3OBJ>(arg3) )
00199                     );
00200                 }
00201             };
00202 
00203             template<class PROXYFUNC>
00204             struct ProxyFunctionCaller<PROXYFUNC, void> {
00205                 inline static Object::Ptr exec(PROXYFUNC* self, Kross::Api::Object* arg1, Kross::Api::Object* arg2, Kross::Api::Object* arg3) {
00206                     ( (self->m_instance)->*(self->m_method) )( ProxyArgTranslator<ARG1OBJ>(arg1), ProxyArgTranslator<ARG2OBJ>(arg2), ProxyArgTranslator<ARG3OBJ>(arg3) );
00207                     return 0;
00208                 }
00209             };
00210 
00211         public:
00212             ProxyFunction(INSTANCE* instance, const METHOD& method, ARG1OBJ* defarg1 = 0, ARG2OBJ* defarg2 = 0, ARG3OBJ* defarg3 = 0)
00213                 : m_instance(instance), m_method(method), m_defarg1(defarg1), m_defarg2(defarg2), m_defarg3(defarg3) {}
00214             Object::Ptr call(List::Ptr args) {
00215                 return ProxyFunctionCaller<ProxyFunction, RETURNOBJ>::exec(this,
00216                     args->item(0, m_defarg1), args->item(1, m_defarg2), args->item(2, m_defarg3)
00217                 );
00218             }
00219     };
00220 
00224     template<class INSTANCE, typename METHOD, class RETURNOBJ, class ARG1OBJ, class ARG2OBJ>
00225     class ProxyFunction<INSTANCE, METHOD, RETURNOBJ, ARG1OBJ, ARG2OBJ> : public Function
00226     {
00227             template<class PROXYFUNC, typename RETURNTYPE>
00228             friend struct ProxyFunctionCaller;
00229         private:
00230             INSTANCE* m_instance;
00231             const METHOD m_method;
00232             KSharedPtr<ARG1OBJ> m_defarg1;
00233             KSharedPtr<ARG2OBJ> m_defarg2;
00234 
00235             template<class PROXYFUNC, typename RETURNTYPE>
00236             struct ProxyFunctionCaller {
00237                 inline static Object::Ptr exec(PROXYFUNC* self, Kross::Api::Object* arg1, Kross::Api::Object* arg2) {
00238                     return ProxyRetTranslator::cast<RETURNTYPE>(
00239                         ( (self->m_instance)->*(self->m_method) )( ProxyArgTranslator<ARG1OBJ>(arg1), ProxyArgTranslator<ARG2OBJ>(arg2) )
00240                     );
00241                 }
00242             };
00243 
00244             template<class PROXYFUNC>
00245             struct ProxyFunctionCaller<PROXYFUNC, void> {
00246                 inline static Object::Ptr exec(PROXYFUNC* self, Kross::Api::Object* arg1, Kross::Api::Object* arg2) {
00247                     ( (self->m_instance)->*(self->m_method) )( ProxyArgTranslator<ARG1OBJ>(arg1), ProxyArgTranslator<ARG2OBJ>(arg2) );
00248                     return 0;
00249                 }
00250             };
00251 
00252         public:
00253             ProxyFunction(INSTANCE* instance, const METHOD& method, ARG1OBJ* defarg1 = 0, ARG2OBJ* defarg2 = 0)
00254                 : m_instance(instance), m_method(method), m_defarg1(defarg1), m_defarg2(defarg2) {}
00255             Object::Ptr call(List::Ptr args) {
00256                 return ProxyFunctionCaller<ProxyFunction, RETURNOBJ>::exec(this,
00257                     args->item(0, m_defarg1), args->item(1, m_defarg2)
00258                 );
00259             }
00260     };
00261 
00265     template<class INSTANCE, typename METHOD, class RETURNOBJ, class ARG1OBJ>
00266     class ProxyFunction<INSTANCE, METHOD, RETURNOBJ, ARG1OBJ> : public Function
00267     {
00268             template<class PROXYFUNC, typename RETURNTYPE>
00269             friend struct ProxyFunctionCaller;
00270         private:
00271             INSTANCE* m_instance;
00272             const METHOD m_method;
00273             KSharedPtr<ARG1OBJ> m_defarg1;
00274 
00275             template<class PROXYFUNC, typename RETURNTYPE>
00276             struct ProxyFunctionCaller {
00277                 inline static Object::Ptr exec(PROXYFUNC* self, Kross::Api::Object* arg1) {
00278                     return ProxyRetTranslator::cast<RETURNTYPE>(
00279                         ( (self->m_instance)->*(self->m_method) )( ProxyArgTranslator<ARG1OBJ>(arg1) )
00280                     );
00281                 }
00282             };
00283 
00284             template<class PROXYFUNC>
00285             struct ProxyFunctionCaller<PROXYFUNC, void> {
00286                 inline static Object::Ptr exec(PROXYFUNC* self, Kross::Api::Object* arg1) {
00287                     ( (self->m_instance)->*(self->m_method) )( ProxyArgTranslator<ARG1OBJ>(arg1) );
00288                     return 0;
00289                 }
00290             };
00291 
00292         public:
00293             ProxyFunction(INSTANCE* instance, const METHOD& method, ARG1OBJ* defarg1 = 0)
00294                 : m_instance(instance), m_method(method), m_defarg1(defarg1) {}
00295             Object::Ptr call(List::Ptr args) {
00296                 return ProxyFunctionCaller<ProxyFunction, RETURNOBJ>::exec(this,
00297                     args->item(0, m_defarg1)
00298                 );
00299             }
00300     };
00301 
00305     template<class INSTANCE, typename METHOD, class RETURNOBJ>
00306     class ProxyFunction<INSTANCE, METHOD, RETURNOBJ> : public Function
00307     {
00308             template<class PROXYFUNC, typename RETURNTYPE>
00309             friend struct ProxyFunctionCaller;
00310         private:
00311             INSTANCE* m_instance;
00312             const METHOD m_method;
00313 
00314             template<class PROXYFUNC, typename RETURNTYPE>
00315             struct ProxyFunctionCaller {
00316                 inline static Object::Ptr exec(PROXYFUNC* self) {
00317                     return ProxyRetTranslator::cast<RETURNTYPE>(
00318                         ( (self->m_instance)->*(self->m_method) )()
00319                     );
00320                 }
00321             };
00322 
00323             template<class PROXYFUNC>
00324             struct ProxyFunctionCaller<PROXYFUNC, void> {
00325                 inline static Object::Ptr exec(PROXYFUNC* self) {
00326                     ( (self->m_instance)->*(self->m_method) )();
00327                     return 0;
00328                 }
00329             };
00330 
00331         public:
00332             ProxyFunction(INSTANCE* instance, const METHOD& method)
00333                 : m_instance(instance), m_method(method) {}
00334             Object::Ptr call(List::Ptr) {
00335                 return ProxyFunctionCaller<ProxyFunction, RETURNOBJ>::exec(this);
00336             }
00337     };
00338 
00339 }}
00340 
00341 #endif
00342 
KDE Home | KDE Accessibility Home | Description of Access Keys