PLearn 0.1
RemoteTrampoline.h
Go to the documentation of this file.
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 :
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines