PLearn 0.1
|
00001 // -*- C++ -*- 00002 00003 // RemoteTrampoline.h 00004 // 00005 // Copyright (C) 2006 Nicolas Chapados, Pascal Vincent 00006 // 00007 // Redistribution and use in source and binary forms, with or without 00008 // modification, are permitted provided that the following conditions are met: 00009 // 00010 // 1. Redistributions of source code must retain the above copyright 00011 // notice, this list of conditions and the following disclaimer. 00012 // 00013 // 2. Redistributions in binary form must reproduce the above copyright 00014 // notice, this list of conditions and the following disclaimer in the 00015 // documentation and/or other materials provided with the distribution. 00016 // 00017 // 3. The name of the authors may not be used to endorse or promote 00018 // products derived from this software without specific prior written 00019 // permission. 00020 // 00021 // THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 00022 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 00023 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN 00024 // NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 00025 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 00026 // TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 00027 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 00028 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 00029 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 00030 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 00031 // 00032 // This file is part of the PLearn library. For more information on the PLearn 00033 // library, go to the PLearn Web site at www.plearn.org 00034 00035 // Authors: Nicolas Chapados 00036 00040 #ifndef RemoteTrampoline_INC 00041 #define RemoteTrampoline_INC 00042 00043 // Python includes must come first (if needed) 00044 #ifdef PL_PYTHON_VERSION 00045 #include <plearn/python/PythonObjectWrapper.h> 00046 #endif //def PL_PYTHON_VERSION 00047 00048 00049 // From C++ stdlib 00050 #include <string> 00051 00052 // From Boost 00053 #include <boost/type_traits.hpp> 00054 00055 // From PLearn 00056 #include <plearn/base/PP.h> 00057 #include <plearn/base/TypeTraits.h> 00058 #include <plearn/io/PStream.h> 00059 #include <plearn/base/tuple.h> 00060 #include "RemoteMethodDoc.h" 00061 00062 namespace PLearn { 00063 00064 using std::string; 00065 00066 // Forward-declare 00067 class Object; 00068 00069 // Shortcut for stripping an argument or return type of all references, const, 00070 // and volatile qualifiers 00071 #define TRAMPOLINE_TYPE(T) \ 00072 typename boost::remove_cv< typename boost::remove_reference<T>::type >::type 00073 00074 #define RTYPE_DOC(T) RetTypeDoc(TypeTraits< TRAMPOLINE_TYPE(T) >::name()) 00075 00076 #define ATYPE_DOC(T) ArgTypeDoc(TypeTraits< TRAMPOLINE_TYPE(T) >::name()) 00077 00078 #define FTRAMPOLINE_TYPE(T) \ 00079 boost::remove_cv< boost::remove_reference<T>::type >::type 00080 00081 #define FRTYPE_DOC(T) RetTypeDoc(TypeTraits< FTRAMPOLINE_TYPE(T) >::name()) 00082 00106 struct RemoteTrampoline : public PPointable 00107 { 00109 typedef unsigned int flag_t; 00111 static const flag_t nopython; 00112 00114 RemoteTrampoline(const string& methodname, const RemoteMethodDoc& doc, 00115 const flag_t& flgs= 0) 00116 : m_methodname(methodname), 00117 m_documentation(doc), 00118 m_flags(flgs) 00119 { 00120 m_documentation.setName(methodname); 00121 m_documentation.checkConsistency(); 00122 } 00123 00125 const RemoteMethodDoc& documentation() const 00126 { 00127 return m_documentation; 00128 } 00129 00131 const flag_t& flags() const { return m_flags; } 00132 00142 virtual void call(Object* instance, int nargs, PStream& io) const = 0; 00143 00144 #ifdef PL_PYTHON_VERSION 00145 00146 virtual PythonObjectWrapper call(Object* instance, 00147 const TVec<PythonObjectWrapper>& args) const = 0; 00148 #endif //def PL_PYTHON_VERSION 00149 00150 00152 void checkNargs(int nargs, int expected_nargs) const; 00153 00155 template <class T> 00156 T* as(Object* instance) const 00157 { 00158 T* t_instance = dynamic_cast<T*>(instance); 00159 if (! t_instance) 00160 PLERROR("PLearn Remote Function: object instance is null or of the wrong " 00161 "type for remote function '%s'", m_methodname.c_str()); 00162 00163 return t_instance; 00164 } 00165 00168 static void prepareToSendResults(PStream& out, int nres); 00169 00170 static void sendRemoteMethodVoidResult(PStream& io) 00171 { 00172 prepareToSendResults(io, 0); 00173 io.flush(); 00174 } 00175 00176 template<class T> 00177 static void sendRemoteMethodResult(PStream& io, const T& r) 00178 { 00179 prepareToSendResults(io, 1); 00180 io << r; 00181 io.flush(); 00182 } 00183 00184 template<class T1> 00185 static void sendRemoteMethodResult(PStream& io, const tuple<T1>& r) 00186 { 00187 prepareToSendResults(io, 1); 00188 io << get<0>(r); 00189 io.flush(); 00190 } 00191 00192 template<class T1, class T2> 00193 static void sendRemoteMethodResult(PStream& io, const tuple<T1,T2>& r) 00194 { 00195 prepareToSendResults(io, 2); 00196 io << get<0>(r) << get<1>(r); 00197 io.flush(); 00198 } 00199 00200 template<class T1, class T2, class T3> 00201 static void sendRemoteMethodResult(PStream& io, const tuple<T1,T2,T3>& r) 00202 { 00203 prepareToSendResults(io, 3); 00204 io << get<0>(r) << get<1>(r) << get<2>(r); 00205 io.flush(); 00206 } 00207 00208 template<class T1, class T2, class T3, class T4> 00209 static void sendRemoteMethodResult(PStream& io, const tuple<T1,T2,T3,T4>& r) 00210 { 00211 prepareToSendResults(io, 4); 00212 io << get<0>(r) << get<1>(r) << get<2>(r) << get<3>(r); 00213 io.flush(); 00214 } 00215 00216 template<class T1, class T2, class T3, class T4, class T5> 00217 static void sendRemoteMethodResult(PStream& io, const tuple<T1,T2,T3,T4,T5>& r) 00218 { 00219 prepareToSendResults(io, 5); 00220 io << get<0>(r) << get<1>(r) << get<2>(r) << get<3>(r) << get<4>(r); 00221 io.flush(); 00222 } 00223 00224 template<class T1, class T2, class T3, class T4, class T5, class T6> 00225 static void sendRemoteMethodResult(PStream& io, const tuple<T1,T2,T3,T4,T5,T6>& r) 00226 { 00227 prepareToSendResults(io, 6); 00228 io << get<0>(r) << get<1>(r) << get<2>(r) << get<3>(r) << get<4>(r) << get<5>(r); 00229 io.flush(); 00230 } 00231 00232 protected: 00234 string m_methodname; 00235 00237 RemoteMethodDoc m_documentation; 00238 00240 flag_t m_flags; 00241 }; 00242 00243 //##### Zero Arguments ###################################################### 00244 00248 template <class T, class R> 00249 struct RemoteTrampoline_0 : public RemoteTrampoline 00250 { 00251 typedef RemoteTrampoline inherited; 00252 enum { expected_nargs = 0 }; 00253 typedef R (T::*MethodType)(); 00254 00255 RemoteTrampoline_0(const string& methodname, const RemoteMethodDoc& doc, 00256 MethodType m, const flag_t& flgs= 0) 00257 : inherited(methodname, (doc, 00258 RTYPE_DOC(R)), 00259 flgs), 00260 m_method(m) 00261 { } 00262 00263 virtual void call(Object* instance, int nargs, PStream& io) const 00264 { 00265 checkNargs(nargs, expected_nargs); 00266 TRAMPOLINE_TYPE(R) r = (as<T>(instance)->*m_method)(); 00267 sendRemoteMethodResult(io, r); 00268 } 00269 00270 #ifdef PL_PYTHON_VERSION 00271 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00272 { 00273 checkNargs(args.size(), expected_nargs); 00274 TRAMPOLINE_TYPE(R) r = (as<T>(instance)->*m_method)(); 00275 return PythonObjectWrapper(r) ; 00276 } 00277 #endif //def PL_PYTHON_VERSION 00278 00279 protected: 00280 MethodType m_method; 00281 }; 00282 00286 template <class T> 00287 struct RemoteTrampoline_0<T,void> : public RemoteTrampoline 00288 { 00289 typedef RemoteTrampoline inherited; 00290 enum { expected_nargs = 0 }; 00291 typedef void (T::*MethodType)(); 00292 00293 RemoteTrampoline_0(const string& methodname, const RemoteMethodDoc& doc, 00294 MethodType m, const flag_t& flgs= 0) 00295 : inherited(methodname, (doc, 00296 RTYPE_DOC(void)), 00297 flgs), 00298 m_method(m) 00299 { } 00300 00301 virtual void call(Object* instance, int nargs, PStream& io) const 00302 { 00303 checkNargs(nargs, expected_nargs); 00304 (as<T>(instance)->*m_method)(); 00305 sendRemoteMethodVoidResult(io); 00306 } 00307 00308 #ifdef PL_PYTHON_VERSION 00309 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00310 { 00311 checkNargs(args.size(), expected_nargs); 00312 (as<T>(instance)->*m_method)(); 00313 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 00314 } 00315 #endif //def PL_PYTHON_VERSION 00316 00317 protected: 00318 MethodType m_method; 00319 }; 00320 00321 00322 //##### 1 Argument ########################################################## 00323 00327 template <class T, class R, class A1> 00328 struct RemoteTrampoline_1 : public RemoteTrampoline 00329 { 00330 typedef RemoteTrampoline inherited; 00331 enum { expected_nargs = 1 }; 00332 typedef R (T::*MethodType)(A1); 00333 00334 RemoteTrampoline_1(const string& methodname, const RemoteMethodDoc& doc, 00335 MethodType m, const flag_t& flgs= 0) 00336 : inherited(methodname, (doc, 00337 RTYPE_DOC(R), 00338 ATYPE_DOC(A1)), 00339 flgs), 00340 m_method(m) 00341 { } 00342 00343 virtual void call(Object* instance, int nargs, PStream& io) const 00344 { 00345 checkNargs(nargs, expected_nargs); 00346 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00347 TRAMPOLINE_TYPE(R) r = (as<T>(instance)->*m_method)(a1); 00348 sendRemoteMethodResult(io, r); 00349 } 00350 00351 #ifdef PL_PYTHON_VERSION 00352 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00353 { 00354 checkNargs(args.size(), expected_nargs); 00355 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00356 TRAMPOLINE_TYPE(R) r= (as<T>(instance)->*m_method)(a1); 00357 return PythonObjectWrapper(r); 00358 } 00359 #endif //def PL_PYTHON_VERSION 00360 00361 protected: 00362 MethodType m_method; 00363 }; 00364 00368 template <class T, class A1> 00369 struct RemoteTrampoline_1<T,void,A1> : public RemoteTrampoline 00370 { 00371 typedef RemoteTrampoline inherited; 00372 enum { expected_nargs = 1 }; 00373 typedef void (T::*MethodType)(A1); 00374 00375 RemoteTrampoline_1(const string& methodname, const RemoteMethodDoc& doc, 00376 MethodType m, const flag_t& flgs= 0) 00377 : inherited(methodname, (doc, 00378 RTYPE_DOC(void), 00379 ATYPE_DOC(A1)), 00380 flgs), 00381 m_method(m) 00382 { } 00383 00384 virtual void call(Object* instance, int nargs, PStream& io) const 00385 { 00386 checkNargs(nargs, expected_nargs); 00387 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00388 (as<T>(instance)->*m_method)(a1); 00389 sendRemoteMethodVoidResult(io); 00390 } 00391 00392 #ifdef PL_PYTHON_VERSION 00393 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00394 { 00395 checkNargs(args.size(), expected_nargs); 00396 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00397 (as<T>(instance)->*m_method)(a1); 00398 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 00399 } 00400 #endif //def PL_PYTHON_VERSION 00401 00402 protected: 00403 MethodType m_method; 00404 }; 00405 00406 00407 //##### 2 Arguments ######################################################### 00408 00412 template <class T, class R, class A1, class A2> 00413 struct RemoteTrampoline_2 : public RemoteTrampoline 00414 { 00415 typedef RemoteTrampoline inherited; 00416 enum { expected_nargs = 2 }; 00417 typedef R (T::*MethodType)(A1,A2); 00418 00419 RemoteTrampoline_2(const string& methodname, const RemoteMethodDoc& doc, 00420 MethodType m, const flag_t& flgs= 0) 00421 : inherited(methodname, (doc, 00422 RTYPE_DOC(R), 00423 ATYPE_DOC(A1), ATYPE_DOC(A2)), 00424 flgs), 00425 m_method(m) 00426 { } 00427 00428 virtual void call(Object* instance, int nargs, PStream& io) const 00429 { 00430 checkNargs(nargs, expected_nargs); 00431 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00432 TRAMPOLINE_TYPE(A2) a2; io >> a2; 00433 TRAMPOLINE_TYPE(R) r = (as<T>(instance)->*m_method)(a1,a2); 00434 sendRemoteMethodResult(io, r); 00435 } 00436 00437 #ifdef PL_PYTHON_VERSION 00438 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00439 { 00440 checkNargs(args.size(), expected_nargs); 00441 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00442 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 00443 TRAMPOLINE_TYPE(R) r= (as<T>(instance)->*m_method)(a1,a2); 00444 return PythonObjectWrapper(r); 00445 } 00446 #endif //def PL_PYTHON_VERSION 00447 00448 protected: 00449 MethodType m_method; 00450 }; 00451 00455 template <class T, class A1, class A2> 00456 struct RemoteTrampoline_2<T,void,A1,A2> : public RemoteTrampoline 00457 { 00458 typedef RemoteTrampoline inherited; 00459 enum { expected_nargs = 2 }; 00460 typedef void (T::*MethodType)(A1,A2); 00461 00462 RemoteTrampoline_2(const string& methodname, const RemoteMethodDoc& doc, 00463 MethodType m, const flag_t& flgs= 0) 00464 : inherited(methodname, (doc, 00465 RTYPE_DOC(void), 00466 ATYPE_DOC(A1), ATYPE_DOC(A2)), 00467 flgs), 00468 m_method(m) 00469 { } 00470 00471 virtual void call(Object* instance, int nargs, PStream& io) const 00472 { 00473 checkNargs(nargs, expected_nargs); 00474 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00475 TRAMPOLINE_TYPE(A2) a2; io >> a2; 00476 (as<T>(instance)->*m_method)(a1,a2); 00477 sendRemoteMethodVoidResult(io); 00478 } 00479 00480 #ifdef PL_PYTHON_VERSION 00481 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00482 { 00483 checkNargs(args.size(), expected_nargs); 00484 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00485 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 00486 (as<T>(instance)->*m_method)(a1,a2); 00487 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 00488 } 00489 #endif //def PL_PYTHON_VERSION 00490 00491 protected: 00492 MethodType m_method; 00493 }; 00494 00495 00496 //##### 3 Arguments ######################################################### 00497 00501 template <class T, class R, class A1, class A2, class A3> 00502 struct RemoteTrampoline_3 : public RemoteTrampoline 00503 { 00504 typedef RemoteTrampoline inherited; 00505 enum { expected_nargs = 3 }; 00506 typedef R (T::*MethodType)(A1,A2,A3); 00507 00508 RemoteTrampoline_3(const string& methodname, const RemoteMethodDoc& doc, 00509 MethodType m, const flag_t& flgs= 0) 00510 : inherited(methodname, (doc, 00511 RTYPE_DOC(R), 00512 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3)), 00513 flgs), 00514 m_method(m) 00515 { } 00516 00517 virtual void call(Object* instance, int nargs, PStream& io) const 00518 { 00519 checkNargs(nargs, expected_nargs); 00520 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00521 TRAMPOLINE_TYPE(A2) a2; io >> a2; 00522 TRAMPOLINE_TYPE(A3) a3; io >> a3; 00523 TRAMPOLINE_TYPE(R) r = (as<T>(instance)->*m_method)(a1,a2,a3); 00524 sendRemoteMethodResult(io, r); 00525 } 00526 00527 #ifdef PL_PYTHON_VERSION 00528 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00529 { 00530 checkNargs(args.size(), expected_nargs); 00531 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00532 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 00533 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 00534 TRAMPOLINE_TYPE(R) r= (as<T>(instance)->*m_method)(a1,a2,a3); 00535 return PythonObjectWrapper(r); 00536 } 00537 #endif //def PL_PYTHON_VERSION 00538 00539 protected: 00540 MethodType m_method; 00541 }; 00542 00546 template <class T, class A1, class A2, class A3> 00547 struct RemoteTrampoline_3<T,void,A1,A2,A3> : public RemoteTrampoline 00548 { 00549 typedef RemoteTrampoline inherited; 00550 enum { expected_nargs = 3 }; 00551 typedef void (T::*MethodType)(A1,A2,A3); 00552 00553 RemoteTrampoline_3(const string& methodname, const RemoteMethodDoc& doc, 00554 MethodType m, const flag_t& flgs= 0) 00555 : inherited(methodname, (doc, 00556 RTYPE_DOC(void), 00557 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3)), 00558 flgs), 00559 m_method(m) 00560 { } 00561 00562 virtual void call(Object* instance, int nargs, PStream& io) const 00563 { 00564 checkNargs(nargs, expected_nargs); 00565 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00566 TRAMPOLINE_TYPE(A2) a2; io >> a2; 00567 TRAMPOLINE_TYPE(A3) a3; io >> a3; 00568 (as<T>(instance)->*m_method)(a1,a2,a3); 00569 sendRemoteMethodVoidResult(io); 00570 } 00571 00572 #ifdef PL_PYTHON_VERSION 00573 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00574 { 00575 checkNargs(args.size(), expected_nargs); 00576 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00577 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 00578 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 00579 (as<T>(instance)->*m_method)(a1,a2,a3); 00580 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 00581 } 00582 #endif //def PL_PYTHON_VERSION 00583 00584 protected: 00585 MethodType m_method; 00586 }; 00587 00588 00589 //##### 4 Arguments ######################################################### 00590 00594 template <class T, class R, class A1, class A2, class A3, class A4> 00595 struct RemoteTrampoline_4 : public RemoteTrampoline 00596 { 00597 typedef RemoteTrampoline inherited; 00598 enum { expected_nargs = 4 }; 00599 typedef R (T::*MethodType)(A1,A2,A3,A4); 00600 00601 RemoteTrampoline_4(const string& methodname, const RemoteMethodDoc& doc, 00602 MethodType m, const flag_t& flgs= 0) 00603 : inherited(methodname, (doc, 00604 RTYPE_DOC(R), 00605 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 00606 ATYPE_DOC(A4)), 00607 flgs), 00608 m_method(m) 00609 { } 00610 00611 virtual void call(Object* instance, int nargs, PStream& io) const 00612 { 00613 checkNargs(nargs, expected_nargs); 00614 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00615 TRAMPOLINE_TYPE(A2) a2; io >> a2; 00616 TRAMPOLINE_TYPE(A3) a3; io >> a3; 00617 TRAMPOLINE_TYPE(A4) a4; io >> a4; 00618 TRAMPOLINE_TYPE(R) r = (as<T>(instance)->*m_method)(a1,a2,a3,a4); 00619 sendRemoteMethodResult(io, r); 00620 } 00621 00622 #ifdef PL_PYTHON_VERSION 00623 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00624 { 00625 checkNargs(args.size(), expected_nargs); 00626 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00627 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 00628 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 00629 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 00630 TRAMPOLINE_TYPE(R) r= (as<T>(instance)->*m_method)(a1,a2,a3,a4); 00631 return PythonObjectWrapper(r); 00632 } 00633 #endif //def PL_PYTHON_VERSION 00634 00635 protected: 00636 MethodType m_method; 00637 }; 00638 00642 template <class T, class A1, class A2, class A3, class A4> 00643 struct RemoteTrampoline_4<T,void,A1,A2,A3,A4> : public RemoteTrampoline 00644 { 00645 typedef RemoteTrampoline inherited; 00646 enum { expected_nargs = 4 }; 00647 typedef void (T::*MethodType)(A1,A2,A3,A4); 00648 00649 RemoteTrampoline_4(const string& methodname, const RemoteMethodDoc& doc, 00650 MethodType m, const flag_t& flgs= 0) 00651 : inherited(methodname, (doc, 00652 RTYPE_DOC(void), 00653 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 00654 ATYPE_DOC(A4)), 00655 flgs), 00656 m_method(m) 00657 { } 00658 00659 virtual void call(Object* instance, int nargs, PStream& io) const 00660 { 00661 checkNargs(nargs, expected_nargs); 00662 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00663 TRAMPOLINE_TYPE(A2) a2; io >> a2; 00664 TRAMPOLINE_TYPE(A3) a3; io >> a3; 00665 TRAMPOLINE_TYPE(A4) a4; io >> a4; 00666 (as<T>(instance)->*m_method)(a1,a2,a3,a4); 00667 sendRemoteMethodVoidResult(io); 00668 } 00669 00670 #ifdef PL_PYTHON_VERSION 00671 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00672 { 00673 checkNargs(args.size(), expected_nargs); 00674 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00675 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 00676 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 00677 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 00678 (as<T>(instance)->*m_method)(a1,a2,a3,a4); 00679 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 00680 } 00681 #endif //def PL_PYTHON_VERSION 00682 00683 protected: 00684 MethodType m_method; 00685 }; 00686 00687 00688 //##### 5 Arguments ######################################################### 00689 00693 template <class T, class R, class A1, class A2, class A3, class A4, class A5> 00694 struct RemoteTrampoline_5 : public RemoteTrampoline 00695 { 00696 typedef RemoteTrampoline inherited; 00697 enum { expected_nargs = 5 }; 00698 typedef R (T::*MethodType)(A1,A2,A3,A4,A5); 00699 00700 RemoteTrampoline_5(const string& methodname, const RemoteMethodDoc& doc, 00701 MethodType m, const flag_t& flgs= 0) 00702 : inherited(methodname, (doc, 00703 RTYPE_DOC(R), 00704 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 00705 ATYPE_DOC(A4), ATYPE_DOC(A5)), 00706 flgs), 00707 m_method(m) 00708 { } 00709 00710 virtual void call(Object* instance, int nargs, PStream& io) const 00711 { 00712 checkNargs(nargs, expected_nargs); 00713 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00714 TRAMPOLINE_TYPE(A2) a2; io >> a2; 00715 TRAMPOLINE_TYPE(A3) a3; io >> a3; 00716 TRAMPOLINE_TYPE(A4) a4; io >> a4; 00717 TRAMPOLINE_TYPE(A5) a5; io >> a5; 00718 TRAMPOLINE_TYPE(R) r = (as<T>(instance)->*m_method)(a1,a2,a3,a4,a5); 00719 sendRemoteMethodResult(io, r); 00720 } 00721 00722 #ifdef PL_PYTHON_VERSION 00723 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00724 { 00725 checkNargs(args.size(), expected_nargs); 00726 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00727 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 00728 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 00729 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 00730 TRAMPOLINE_TYPE(A5) a5= args[4].as<TRAMPOLINE_TYPE(A5)>(); 00731 TRAMPOLINE_TYPE(R) r= (as<T>(instance)->*m_method)(a1,a2,a3,a4,a5); 00732 return PythonObjectWrapper(r); 00733 } 00734 #endif //def PL_PYTHON_VERSION 00735 00736 protected: 00737 MethodType m_method; 00738 }; 00739 00743 template <class T, class A1, class A2, class A3, class A4, class A5> 00744 struct RemoteTrampoline_5<T,void,A1,A2,A3,A4,A5> : public RemoteTrampoline 00745 { 00746 typedef RemoteTrampoline inherited; 00747 enum { expected_nargs = 5 }; 00748 typedef void (T::*MethodType)(A1,A2,A3,A4,A5); 00749 00750 RemoteTrampoline_5(const string& methodname, const RemoteMethodDoc& doc, 00751 MethodType m, const flag_t& flgs= 0) 00752 : inherited(methodname, (doc, 00753 RTYPE_DOC(void), 00754 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 00755 ATYPE_DOC(A4), ATYPE_DOC(A5)), 00756 flgs), 00757 m_method(m) 00758 { } 00759 00760 virtual void call(Object* instance, int nargs, PStream& io) const 00761 { 00762 checkNargs(nargs, expected_nargs); 00763 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00764 TRAMPOLINE_TYPE(A2) a2; io >> a2; 00765 TRAMPOLINE_TYPE(A3) a3; io >> a3; 00766 TRAMPOLINE_TYPE(A4) a4; io >> a4; 00767 TRAMPOLINE_TYPE(A5) a5; io >> a5; 00768 (as<T>(instance)->*m_method)(a1,a2,a3,a4,a5); 00769 sendRemoteMethodVoidResult(io); 00770 } 00771 00772 #ifdef PL_PYTHON_VERSION 00773 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00774 { 00775 checkNargs(args.size(), expected_nargs); 00776 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00777 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 00778 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 00779 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 00780 TRAMPOLINE_TYPE(A5) a5= args[4].as<TRAMPOLINE_TYPE(A5)>(); 00781 (as<T>(instance)->*m_method)(a1,a2,a3,a4,a5); 00782 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 00783 } 00784 #endif //def PL_PYTHON_VERSION 00785 00786 protected: 00787 MethodType m_method; 00788 }; 00789 00790 00791 //##### 6 Arguments ######################################################### 00792 00796 template <class T, class R, class A1, class A2, class A3, class A4, class A5, class A6> 00797 struct RemoteTrampoline_6 : public RemoteTrampoline 00798 { 00799 typedef RemoteTrampoline inherited; 00800 enum { expected_nargs = 6 }; 00801 typedef R (T::*MethodType)(A1,A2,A3,A4,A5,A6); 00802 00803 RemoteTrampoline_6(const string& methodname, const RemoteMethodDoc& doc, 00804 MethodType m, const flag_t& flgs= 0) 00805 : inherited(methodname, (doc, 00806 RTYPE_DOC(R), 00807 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 00808 ATYPE_DOC(A4), ATYPE_DOC(A5), ATYPE_DOC(A6)), 00809 flgs), 00810 m_method(m) 00811 { } 00812 00813 virtual void call(Object* instance, int nargs, PStream& io) const 00814 { 00815 checkNargs(nargs, expected_nargs); 00816 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00817 TRAMPOLINE_TYPE(A2) a2; io >> a2; 00818 TRAMPOLINE_TYPE(A3) a3; io >> a3; 00819 TRAMPOLINE_TYPE(A4) a4; io >> a4; 00820 TRAMPOLINE_TYPE(A5) a5; io >> a5; 00821 TRAMPOLINE_TYPE(A6) a6; io >> a6; 00822 TRAMPOLINE_TYPE(R) r = (as<T>(instance)->*m_method)(a1,a2,a3,a4,a5,a6); 00823 sendRemoteMethodResult(io, r); 00824 } 00825 00826 #ifdef PL_PYTHON_VERSION 00827 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00828 { 00829 checkNargs(args.size(), expected_nargs); 00830 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00831 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 00832 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 00833 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 00834 TRAMPOLINE_TYPE(A5) a5= args[4].as<TRAMPOLINE_TYPE(A5)>(); 00835 TRAMPOLINE_TYPE(A6) a6= args[5].as<TRAMPOLINE_TYPE(A6)>(); 00836 TRAMPOLINE_TYPE(R) r= (as<T>(instance)->*m_method)(a1,a2,a3,a4,a5,a6); 00837 return PythonObjectWrapper(r); 00838 } 00839 #endif //def PL_PYTHON_VERSION 00840 00841 protected: 00842 MethodType m_method; 00843 }; 00844 00848 template <class T, class A1, class A2, class A3, class A4, class A5, class A6> 00849 struct RemoteTrampoline_6<T,void,A1,A2,A3,A4,A5,A6> : public RemoteTrampoline 00850 { 00851 typedef RemoteTrampoline inherited; 00852 enum { expected_nargs = 6 }; 00853 typedef void (T::*MethodType)(A1,A2,A3,A4,A5,A6); 00854 00855 RemoteTrampoline_6(const string& methodname, const RemoteMethodDoc& doc, 00856 MethodType m, const flag_t& flgs= 0) 00857 : inherited(methodname, (doc, 00858 RTYPE_DOC(void), 00859 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 00860 ATYPE_DOC(A4), ATYPE_DOC(A5), ATYPE_DOC(A6)), 00861 flgs), 00862 m_method(m) 00863 { } 00864 00865 virtual void call(Object* instance, int nargs, PStream& io) const 00866 { 00867 checkNargs(nargs, expected_nargs); 00868 TRAMPOLINE_TYPE(A1) a1; io >> a1; 00869 TRAMPOLINE_TYPE(A2) a2; io >> a2; 00870 TRAMPOLINE_TYPE(A3) a3; io >> a3; 00871 TRAMPOLINE_TYPE(A4) a4; io >> a4; 00872 TRAMPOLINE_TYPE(A5) a5; io >> a5; 00873 TRAMPOLINE_TYPE(A6) a6; io >> a6; 00874 (as<T>(instance)->*m_method)(a1,a2,a3,a4,a5,a6); 00875 sendRemoteMethodVoidResult(io); 00876 } 00877 00878 #ifdef PL_PYTHON_VERSION 00879 virtual PythonObjectWrapper call(Object* instance, const TVec<PythonObjectWrapper>& args) const 00880 { 00881 checkNargs(args.size(), expected_nargs); 00882 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 00883 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 00884 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 00885 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 00886 TRAMPOLINE_TYPE(A5) a5= args[4].as<TRAMPOLINE_TYPE(A5)>(); 00887 TRAMPOLINE_TYPE(A6) a6= args[5].as<TRAMPOLINE_TYPE(A6)>(); 00888 (as<T>(instance)->*m_method)(a1,a2,a3,a4,a5,a6); 00889 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 00890 } 00891 #endif //def PL_PYTHON_VERSION 00892 00893 protected: 00894 MethodType m_method; 00895 }; 00896 00897 00903 00904 00905 //##### Zero Arguments ###################################################### 00906 00910 template <class R> 00911 struct FRemoteTrampoline_0 : public RemoteTrampoline 00912 { 00913 typedef RemoteTrampoline inherited; 00914 enum { expected_nargs = 0 }; 00915 typedef R (*FunctionType)(); 00916 00917 FRemoteTrampoline_0(const string& functionname, const RemoteMethodDoc& doc, 00918 FunctionType m, const flag_t& flgs= 0) 00919 : inherited(functionname, (doc, 00920 RTYPE_DOC(R)), 00921 flgs), 00922 m_function(m) 00923 { } 00924 00925 virtual void call(Object* nullinstance, int nargs, PStream& io) const 00926 { 00927 checkNargs(nargs, expected_nargs); 00928 TRAMPOLINE_TYPE(R) r = (*m_function)(); 00929 sendRemoteMethodResult(io, r); 00930 } 00931 00932 #ifdef PL_PYTHON_VERSION 00933 virtual PythonObjectWrapper call(Object* nullinstance, 00934 const TVec<PythonObjectWrapper>& args) const 00935 { 00936 checkNargs(args.size(), expected_nargs); 00937 TRAMPOLINE_TYPE(R) r= (*m_function)(); 00938 return PythonObjectWrapper(r); 00939 } 00940 #endif //def PL_PYTHON_VERSION 00941 00942 protected: 00943 FunctionType m_function; 00944 }; 00945 00949 template <> 00950 struct FRemoteTrampoline_0<void> : public RemoteTrampoline 00951 { 00952 typedef RemoteTrampoline inherited; 00953 enum { expected_nargs = 0 }; 00954 typedef void (*FunctionType)(); 00955 00956 FRemoteTrampoline_0(const string& functionname, const RemoteMethodDoc& doc, 00957 FunctionType m, const flag_t& flgs= 0) 00958 : inherited(functionname, (doc, RetTypeDoc("void")), flgs), 00959 m_function(m) 00960 { } 00961 00962 virtual void call(Object* nullinstance, int nargs, PStream& io) const 00963 { 00964 checkNargs(nargs, expected_nargs); 00965 (*m_function)(); 00966 sendRemoteMethodVoidResult(io); 00967 } 00968 00969 #ifdef PL_PYTHON_VERSION 00970 virtual PythonObjectWrapper call(Object* nullinstance, 00971 const TVec<PythonObjectWrapper>& args) const 00972 { 00973 checkNargs(args.size(), expected_nargs); 00974 (*m_function)(); 00975 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 00976 } 00977 #endif //def PL_PYTHON_VERSION 00978 00979 protected: 00980 FunctionType m_function; 00981 }; 00982 00983 00984 //##### 1 Argument ########################################################## 00985 00989 template <class R, class A1> 00990 struct FRemoteTrampoline_1 : public RemoteTrampoline 00991 { 00992 typedef RemoteTrampoline inherited; 00993 enum { expected_nargs = 1 }; 00994 typedef R (*FunctionType)(A1); 00995 00996 FRemoteTrampoline_1(const string& functionname, const RemoteMethodDoc& doc, 00997 FunctionType m, const flag_t& flgs= 0) 00998 : inherited(functionname, (doc, 00999 RTYPE_DOC(R), 01000 ATYPE_DOC(A1)), 01001 flgs), 01002 m_function(m) 01003 { } 01004 01005 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01006 { 01007 checkNargs(nargs, expected_nargs); 01008 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01009 TRAMPOLINE_TYPE(R) r = (*m_function)(a1); 01010 sendRemoteMethodResult(io, r); 01011 } 01012 01013 #ifdef PL_PYTHON_VERSION 01014 virtual PythonObjectWrapper call(Object* nullinstance, 01015 const TVec<PythonObjectWrapper>& args) const 01016 { 01017 checkNargs(args.size(), expected_nargs); 01018 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01019 TRAMPOLINE_TYPE(R) r= (*m_function)(a1); 01020 return PythonObjectWrapper(r); 01021 } 01022 #endif //def PL_PYTHON_VERSION 01023 01024 protected: 01025 FunctionType m_function; 01026 }; 01027 01031 template <class A1> 01032 struct FRemoteTrampoline_1<void,A1> : public RemoteTrampoline 01033 { 01034 typedef RemoteTrampoline inherited; 01035 enum { expected_nargs = 1 }; 01036 typedef void (*FunctionType)(A1); 01037 01038 FRemoteTrampoline_1(const string& functionname, const RemoteMethodDoc& doc, 01039 FunctionType m, const flag_t& flgs= 0) 01040 : inherited(functionname, (doc, 01041 RTYPE_DOC(void), 01042 ATYPE_DOC(A1)), 01043 flgs), 01044 m_function(m) 01045 { } 01046 01047 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01048 { 01049 checkNargs(nargs, expected_nargs); 01050 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01051 (*m_function)(a1); 01052 sendRemoteMethodVoidResult(io); 01053 } 01054 01055 #ifdef PL_PYTHON_VERSION 01056 virtual PythonObjectWrapper call(Object* nullinstance, 01057 const TVec<PythonObjectWrapper>& args) const 01058 { 01059 checkNargs(args.size(), expected_nargs); 01060 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01061 (*m_function)(a1); 01062 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 01063 } 01064 #endif //def PL_PYTHON_VERSION 01065 01066 protected: 01067 FunctionType m_function; 01068 }; 01069 01070 01071 //##### 2 Arguments ######################################################### 01072 01076 template <class R, class A1, class A2> 01077 struct FRemoteTrampoline_2 : public RemoteTrampoline 01078 { 01079 typedef RemoteTrampoline inherited; 01080 enum { expected_nargs = 2 }; 01081 typedef R (*FunctionType)(A1,A2); 01082 01083 FRemoteTrampoline_2(const string& functionname, const RemoteMethodDoc& doc, 01084 FunctionType m, const flag_t& flgs= 0) 01085 : inherited(functionname, (doc, 01086 RTYPE_DOC(R), 01087 ATYPE_DOC(A1), ATYPE_DOC(A2)), 01088 flgs), 01089 m_function(m) 01090 { } 01091 01092 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01093 { 01094 checkNargs(nargs, expected_nargs); 01095 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01096 TRAMPOLINE_TYPE(A2) a2; io >> a2; 01097 TRAMPOLINE_TYPE(R) r = (*m_function)(a1,a2); 01098 sendRemoteMethodResult(io, r); 01099 } 01100 01101 #ifdef PL_PYTHON_VERSION 01102 virtual PythonObjectWrapper call(Object* nullinstance, 01103 const TVec<PythonObjectWrapper>& args) const 01104 { 01105 checkNargs(args.size(), expected_nargs); 01106 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01107 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 01108 TRAMPOLINE_TYPE(R) r= (*m_function)(a1,a2); 01109 return PythonObjectWrapper(r); 01110 } 01111 #endif //def PL_PYTHON_VERSION 01112 01113 protected: 01114 FunctionType m_function; 01115 }; 01116 01120 template <class A1, class A2> 01121 struct FRemoteTrampoline_2<void,A1,A2> : public RemoteTrampoline 01122 { 01123 typedef RemoteTrampoline inherited; 01124 enum { expected_nargs = 2 }; 01125 typedef void (*FunctionType)(A1,A2); 01126 01127 FRemoteTrampoline_2(const string& functionname, const RemoteMethodDoc& doc, 01128 FunctionType m, const flag_t& flgs= 0) 01129 : inherited(functionname, (doc, 01130 RTYPE_DOC(void), 01131 ATYPE_DOC(A1), ATYPE_DOC(A2)), 01132 flgs), 01133 m_function(m) 01134 { } 01135 01136 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01137 { 01138 checkNargs(nargs, expected_nargs); 01139 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01140 TRAMPOLINE_TYPE(A2) a2; io >> a2; 01141 (*m_function)(a1,a2); 01142 sendRemoteMethodVoidResult(io); 01143 } 01144 01145 #ifdef PL_PYTHON_VERSION 01146 virtual PythonObjectWrapper call(Object* nullinstance, 01147 const TVec<PythonObjectWrapper>& args) const 01148 { 01149 checkNargs(args.size(), expected_nargs); 01150 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01151 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 01152 (*m_function)(a1,a2); 01153 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 01154 } 01155 #endif //def PL_PYTHON_VERSION 01156 01157 protected: 01158 FunctionType m_function; 01159 }; 01160 01161 01162 //##### 3 Arguments ######################################################### 01163 01167 template <class R, class A1, class A2, class A3> 01168 struct FRemoteTrampoline_3 : public RemoteTrampoline 01169 { 01170 typedef RemoteTrampoline inherited; 01171 enum { expected_nargs = 3 }; 01172 typedef R (*FunctionType)(A1,A2,A3); 01173 01174 FRemoteTrampoline_3(const string& functionname, const RemoteMethodDoc& doc, 01175 FunctionType m, const flag_t& flgs= 0) 01176 : inherited(functionname, (doc, 01177 RTYPE_DOC(R), 01178 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3)), 01179 flgs), 01180 m_function(m) 01181 { } 01182 01183 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01184 { 01185 checkNargs(nargs, expected_nargs); 01186 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01187 TRAMPOLINE_TYPE(A2) a2; io >> a2; 01188 TRAMPOLINE_TYPE(A3) a3; io >> a3; 01189 TRAMPOLINE_TYPE(R) r = (*m_function)(a1,a2,a3); 01190 sendRemoteMethodResult(io, r); 01191 } 01192 01193 #ifdef PL_PYTHON_VERSION 01194 virtual PythonObjectWrapper call(Object* nullinstance, 01195 const TVec<PythonObjectWrapper>& args) const 01196 { 01197 checkNargs(args.size(), expected_nargs); 01198 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01199 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 01200 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 01201 TRAMPOLINE_TYPE(R) r= (*m_function)(a1,a2,a3); 01202 return PythonObjectWrapper(r); 01203 } 01204 #endif //def PL_PYTHON_VERSION 01205 01206 protected: 01207 FunctionType m_function; 01208 }; 01209 01213 template <class A1, class A2, class A3> 01214 struct FRemoteTrampoline_3<void,A1,A2,A3> : public RemoteTrampoline 01215 { 01216 typedef RemoteTrampoline inherited; 01217 enum { expected_nargs = 3 }; 01218 typedef void (*FunctionType)(A1,A2,A3); 01219 01220 FRemoteTrampoline_3(const string& functionname, const RemoteMethodDoc& doc, 01221 FunctionType m, const flag_t& flgs= 0) 01222 : inherited(functionname, (doc, 01223 RTYPE_DOC(void), 01224 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3)), 01225 flgs), 01226 m_function(m) 01227 { } 01228 01229 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01230 { 01231 checkNargs(nargs, expected_nargs); 01232 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01233 TRAMPOLINE_TYPE(A2) a2; io >> a2; 01234 TRAMPOLINE_TYPE(A3) a3; io >> a3; 01235 (*m_function)(a1,a2,a3); 01236 sendRemoteMethodVoidResult(io); 01237 } 01238 01239 #ifdef PL_PYTHON_VERSION 01240 virtual PythonObjectWrapper call(Object* nullinstance, 01241 const TVec<PythonObjectWrapper>& args) const 01242 { 01243 checkNargs(args.size(), expected_nargs); 01244 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01245 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 01246 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 01247 (*m_function)(a1,a2,a3); 01248 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 01249 } 01250 #endif //def PL_PYTHON_VERSION 01251 01252 protected: 01253 FunctionType m_function; 01254 }; 01255 01256 01257 //##### 4 Arguments ######################################################### 01258 01262 template <class R, class A1, class A2, class A3, class A4> 01263 struct FRemoteTrampoline_4 : public RemoteTrampoline 01264 { 01265 typedef RemoteTrampoline inherited; 01266 enum { expected_nargs = 4 }; 01267 typedef R (*FunctionType)(A1,A2,A3,A4); 01268 01269 FRemoteTrampoline_4(const string& functionname, const RemoteMethodDoc& doc, 01270 FunctionType m, const flag_t& flgs= 0) 01271 : inherited(functionname, (doc, 01272 RTYPE_DOC(R), 01273 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 01274 ATYPE_DOC(A4)), 01275 flgs), 01276 m_function(m) 01277 { } 01278 01279 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01280 { 01281 checkNargs(nargs, expected_nargs); 01282 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01283 TRAMPOLINE_TYPE(A2) a2; io >> a2; 01284 TRAMPOLINE_TYPE(A3) a3; io >> a3; 01285 TRAMPOLINE_TYPE(A4) a4; io >> a4; 01286 TRAMPOLINE_TYPE(R) r = (*m_function)(a1,a2,a3,a4); 01287 sendRemoteMethodResult(io, r); 01288 } 01289 01290 #ifdef PL_PYTHON_VERSION 01291 virtual PythonObjectWrapper call(Object* nullinstance, 01292 const TVec<PythonObjectWrapper>& args) const 01293 { 01294 checkNargs(args.size(), expected_nargs); 01295 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01296 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 01297 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 01298 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 01299 TRAMPOLINE_TYPE(R) r= (*m_function)(a1,a2,a3,a4); 01300 return PythonObjectWrapper(r); 01301 } 01302 #endif //def PL_PYTHON_VERSION 01303 01304 protected: 01305 FunctionType m_function; 01306 }; 01307 01311 template <class A1, class A2, class A3, class A4> 01312 struct FRemoteTrampoline_4<void,A1,A2,A3,A4> : public RemoteTrampoline 01313 { 01314 typedef RemoteTrampoline inherited; 01315 enum { expected_nargs = 4 }; 01316 typedef void (*FunctionType)(A1,A2,A3,A4); 01317 01318 FRemoteTrampoline_4(const string& functionname, const RemoteMethodDoc& doc, 01319 FunctionType m, const flag_t& flgs= 0) 01320 : inherited(functionname, (doc, 01321 RTYPE_DOC(void), 01322 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 01323 ATYPE_DOC(A4)), 01324 flgs), 01325 m_function(m) 01326 { } 01327 01328 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01329 { 01330 checkNargs(nargs, expected_nargs); 01331 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01332 TRAMPOLINE_TYPE(A2) a2; io >> a2; 01333 TRAMPOLINE_TYPE(A3) a3; io >> a3; 01334 TRAMPOLINE_TYPE(A4) a4; io >> a4; 01335 (*m_function)(a1,a2,a3,a4); 01336 sendRemoteMethodVoidResult(io); 01337 } 01338 01339 #ifdef PL_PYTHON_VERSION 01340 virtual PythonObjectWrapper call(Object* nullinstance, 01341 const TVec<PythonObjectWrapper>& args) const 01342 { 01343 checkNargs(args.size(), expected_nargs); 01344 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01345 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 01346 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 01347 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 01348 (*m_function)(a1,a2,a3,a4); 01349 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 01350 } 01351 #endif //def PL_PYTHON_VERSION 01352 01353 protected: 01354 FunctionType m_function; 01355 }; 01356 01357 01358 //##### 5 Arguments ######################################################### 01359 01363 template <class R, class A1, class A2, class A3, class A4, class A5> 01364 struct FRemoteTrampoline_5 : public RemoteTrampoline 01365 { 01366 typedef RemoteTrampoline inherited; 01367 enum { expected_nargs = 5 }; 01368 typedef R (*FunctionType)(A1,A2,A3,A4,A5); 01369 01370 FRemoteTrampoline_5(const string& functionname, const RemoteMethodDoc& doc, 01371 FunctionType m, const flag_t& flgs= 0) 01372 : inherited(functionname, (doc, 01373 RTYPE_DOC(R), 01374 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 01375 ATYPE_DOC(A4), ATYPE_DOC(A5)), 01376 flgs), 01377 m_function(m) 01378 { } 01379 01380 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01381 { 01382 checkNargs(nargs, expected_nargs); 01383 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01384 TRAMPOLINE_TYPE(A2) a2; io >> a2; 01385 TRAMPOLINE_TYPE(A3) a3; io >> a3; 01386 TRAMPOLINE_TYPE(A4) a4; io >> a4; 01387 TRAMPOLINE_TYPE(A5) a5; io >> a5; 01388 TRAMPOLINE_TYPE(R) r = (*m_function)(a1,a2,a3,a4,a5); 01389 sendRemoteMethodResult(io, r); 01390 } 01391 01392 #ifdef PL_PYTHON_VERSION 01393 virtual PythonObjectWrapper call(Object* nullinstance, 01394 const TVec<PythonObjectWrapper>& args) const 01395 { 01396 checkNargs(args.size(), expected_nargs); 01397 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01398 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 01399 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 01400 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 01401 TRAMPOLINE_TYPE(A5) a5= args[4].as<TRAMPOLINE_TYPE(A5)>(); 01402 TRAMPOLINE_TYPE(R) r= (*m_function)(a1,a2,a3,a4,a5); 01403 return PythonObjectWrapper(r); 01404 } 01405 #endif //def PL_PYTHON_VERSION 01406 01407 protected: 01408 FunctionType m_function; 01409 }; 01410 01414 template <class A1, class A2, class A3, class A4, class A5> 01415 struct FRemoteTrampoline_5<void,A1,A2,A3,A4,A5> : public RemoteTrampoline 01416 { 01417 typedef RemoteTrampoline inherited; 01418 enum { expected_nargs = 5 }; 01419 typedef void (*FunctionType)(A1,A2,A3,A4,A5); 01420 01421 FRemoteTrampoline_5(const string& functionname, const RemoteMethodDoc& doc, 01422 FunctionType m, const flag_t& flgs= 0) 01423 : inherited(functionname, (doc, 01424 RTYPE_DOC(void), 01425 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 01426 ATYPE_DOC(A4), ATYPE_DOC(A5)), 01427 flgs), 01428 m_function(m) 01429 { } 01430 01431 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01432 { 01433 checkNargs(nargs, expected_nargs); 01434 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01435 TRAMPOLINE_TYPE(A2) a2; io >> a2; 01436 TRAMPOLINE_TYPE(A3) a3; io >> a3; 01437 TRAMPOLINE_TYPE(A4) a4; io >> a4; 01438 TRAMPOLINE_TYPE(A5) a5; io >> a5; 01439 (*m_function)(a1,a2,a3,a4,a5); 01440 sendRemoteMethodVoidResult(io); 01441 } 01442 01443 #ifdef PL_PYTHON_VERSION 01444 virtual PythonObjectWrapper call(Object* nullinstance, 01445 const TVec<PythonObjectWrapper>& args) const 01446 { 01447 checkNargs(args.size(), expected_nargs); 01448 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01449 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 01450 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 01451 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 01452 TRAMPOLINE_TYPE(A5) a5= args[4].as<TRAMPOLINE_TYPE(A5)>(); 01453 (*m_function)(a1,a2,a3,a4,a5); 01454 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 01455 } 01456 #endif //def PL_PYTHON_VERSION 01457 01458 protected: 01459 FunctionType m_function; 01460 }; 01461 01462 01463 //##### 6 Arguments ######################################################### 01464 01468 template <class R, class A1, class A2, class A3, class A4, class A5, class A6> 01469 struct FRemoteTrampoline_6 : public RemoteTrampoline 01470 { 01471 typedef RemoteTrampoline inherited; 01472 enum { expected_nargs = 6 }; 01473 typedef R (*FunctionType)(A1,A2,A3,A4,A5,A6); 01474 01475 FRemoteTrampoline_6(const string& functionname, const RemoteMethodDoc& doc, 01476 FunctionType m, const flag_t& flgs= 0) 01477 : inherited(functionname, (doc, 01478 RTYPE_DOC(R), 01479 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 01480 ATYPE_DOC(A4), ATYPE_DOC(A5), ATYPE_DOC(A6)), 01481 flgs), 01482 m_function(m) 01483 { } 01484 01485 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01486 { 01487 checkNargs(nargs, expected_nargs); 01488 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01489 TRAMPOLINE_TYPE(A2) a2; io >> a2; 01490 TRAMPOLINE_TYPE(A3) a3; io >> a3; 01491 TRAMPOLINE_TYPE(A4) a4; io >> a4; 01492 TRAMPOLINE_TYPE(A5) a5; io >> a5; 01493 TRAMPOLINE_TYPE(A6) a6; io >> a6; 01494 TRAMPOLINE_TYPE(R) r = (*m_function)(a1,a2,a3,a4,a5,a6); 01495 sendRemoteMethodResult(io, r); 01496 } 01497 01498 #ifdef PL_PYTHON_VERSION 01499 virtual PythonObjectWrapper call(Object* nullinstance, 01500 const TVec<PythonObjectWrapper>& args) const 01501 { 01502 checkNargs(args.size(), expected_nargs); 01503 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01504 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 01505 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 01506 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 01507 TRAMPOLINE_TYPE(A5) a5= args[4].as<TRAMPOLINE_TYPE(A5)>(); 01508 TRAMPOLINE_TYPE(A6) a6= args[5].as<TRAMPOLINE_TYPE(A6)>(); 01509 TRAMPOLINE_TYPE(R) r= (*m_function)(a1,a2,a3,a4,a5,a6); 01510 return PythonObjectWrapper(r); 01511 } 01512 #endif //def PL_PYTHON_VERSION 01513 01514 protected: 01515 FunctionType m_function; 01516 }; 01517 01521 template <class A1, class A2, class A3, class A4, class A5, class A6> 01522 struct FRemoteTrampoline_6<void,A1,A2,A3,A4,A5,A6> : public RemoteTrampoline 01523 { 01524 typedef RemoteTrampoline inherited; 01525 enum { expected_nargs = 6 }; 01526 typedef void (*FunctionType)(A1,A2,A3,A4,A5,A6); 01527 01528 FRemoteTrampoline_6(const string& functionname, const RemoteMethodDoc& doc, 01529 FunctionType m, const flag_t& flgs= 0) 01530 : inherited(functionname, (doc, 01531 RTYPE_DOC(void), 01532 ATYPE_DOC(A1), ATYPE_DOC(A2), ATYPE_DOC(A3), 01533 ATYPE_DOC(A4), ATYPE_DOC(A5), ATYPE_DOC(A6)), 01534 flgs), 01535 m_function(m) 01536 { } 01537 01538 virtual void call(Object* nullinstance, int nargs, PStream& io) const 01539 { 01540 checkNargs(nargs, expected_nargs); 01541 TRAMPOLINE_TYPE(A1) a1; io >> a1; 01542 TRAMPOLINE_TYPE(A2) a2; io >> a2; 01543 TRAMPOLINE_TYPE(A3) a3; io >> a3; 01544 TRAMPOLINE_TYPE(A4) a4; io >> a4; 01545 TRAMPOLINE_TYPE(A5) a5; io >> a5; 01546 TRAMPOLINE_TYPE(A6) a6; io >> a6; 01547 (*m_function)(a1,a2,a3,a4,a5,a6); 01548 sendRemoteMethodVoidResult(io); 01549 } 01550 01551 #ifdef PL_PYTHON_VERSION 01552 virtual PythonObjectWrapper call(Object* nullinstance, 01553 const TVec<PythonObjectWrapper>& args) const 01554 { 01555 checkNargs(args.size(), expected_nargs); 01556 TRAMPOLINE_TYPE(A1) a1= args[0].as<TRAMPOLINE_TYPE(A1)>(); 01557 TRAMPOLINE_TYPE(A2) a2= args[1].as<TRAMPOLINE_TYPE(A2)>(); 01558 TRAMPOLINE_TYPE(A3) a3= args[2].as<TRAMPOLINE_TYPE(A3)>(); 01559 TRAMPOLINE_TYPE(A4) a4= args[3].as<TRAMPOLINE_TYPE(A4)>(); 01560 TRAMPOLINE_TYPE(A5) a5= args[4].as<TRAMPOLINE_TYPE(A5)>(); 01561 TRAMPOLINE_TYPE(A6) a6= args[5].as<TRAMPOLINE_TYPE(A6)>(); 01562 (*m_function)(a1,a2,a3,a4,a5,a6); 01563 return PythonObjectWrapper(PythonObjectWrapper::transfer_ownership);//None 01564 } 01565 #endif //def PL_PYTHON_VERSION 01566 01567 protected: 01568 FunctionType m_function; 01569 }; 01570 01571 } // end of namespace PLearn 01572 01573 #endif 01574 01575 01576 /* 01577 Local Variables: 01578 mode:c++ 01579 c-basic-offset:4 01580 c-file-style:"stroustrup" 01581 c-file-offsets:((innamespace . 0)(inline-open . 0)) 01582 indent-tabs-mode:nil 01583 fill-column:79 01584 End: 01585 */ 01586 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=79 :