00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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,
00096 typename METHOD,
00097 class RETURNOBJ,
00098 class ARG1OBJ = Kross::Api::Object,
00099 class ARG2OBJ = Kross::Api::Object,
00100 class ARG3OBJ = Kross::Api::Object,
00101 class ARG4OBJ = Kross::Api::Object
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;
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