OpenSG: OSGTypedFunctors.inl Source File

00001 /*---------------------------------------------------------------------------*\
00002  *                                OpenSG                                     *
00003  *                                                                           *
00004  *                                                                           *
00005  *             Copyright (C) 2002 by the OpenSG Forum                        *
00006  *                                                                           *
00007  *                            www.opensg.org                                 *
00008  *                                                                           *
00009  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
00010  *                                                                           *
00011 \*---------------------------------------------------------------------------*/
00012 /*---------------------------------------------------------------------------*\
00013  *                                License                                    *
00014  *                                                                           *
00015  * This library is free software; you can redistribute it and/or modify it   *
00016  * under the terms of the GNU Library General Public License as published    *
00017  * by the Free Software Foundation, version 2.                               *
00018  *                                                                           *
00019  * This library is distributed in the hope that it will be useful, but       *
00020  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
00021  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
00022  * Library General Public License for more details.                          *
00023  *                                                                           *
00024  * You should have received a copy of the GNU Library General Public         *
00025  * License along with this library; if not, write to the Free Software       *
00026  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
00027  *                                                                           *
00028 \*---------------------------------------------------------------------------*/
00029 /*---------------------------------------------------------------------------*\
00030  *                                Changes                                    *
00031  *                                                                           *
00032  *                                                                           *
00033  *                                                                           *
00034  *                                                                           *
00035  *                                                                           *
00036  *                                                                           *
00037 \*---------------------------------------------------------------------------*/
00038 
00039 //---------------------------------------------------------------------------
00040 //  Includes
00041 //---------------------------------------------------------------------------
00042 
00043 #include <stdlib.h>
00044 #include <stdio.h>
00045 
00046 #include "OSGConfig.h"
00047 
00048 #include <iostream>
00049 
00050 OSG_BEGIN_NAMESPACE
00051 
00052 //---------------------------------------------------------------------------
00053 //  osgTypedFunctionFunctor1Ptr
00054 //---------------------------------------------------------------------------
00055 
00056 
00057 template <class RetT, class Arg1T> inline
00058 TypedFunctionFunctor1<RetT, PtrCallArg<Arg1T> > osgTypedFunctionFunctor1Ptr   (
00059     RetT (*pFunc)(Arg1T *))
00060 {
00061     TypedFunctionFunctor1<RetT, PtrCallArg<Arg1T> > returnValue;
00062 
00063     returnValue.setMethod(pFunc);
00064 
00065     return returnValue;
00066 }
00067 
00068 
00069 template <class Arg1T> inline
00070 TypedFunctionVoidFunctor1< PtrCallArg<Arg1T> > osgTypedFunctionVoidFunctor1Ptr(
00071     void (*pFunc)(Arg1T *))
00072 {
00073     TypedFunctionVoidFunctor1< PtrCallArg<Arg1T> > returnValue;
00074 
00075     returnValue.setMethod(pFunc);
00076 
00077     return returnValue;
00078 }
00079 
00080 
00081 //---------------------------------------------------------------------------
00082 //  osgTypedFunctionFunctor1Ref
00083 //---------------------------------------------------------------------------
00084 
00085 
00086 template <class RetT, class Arg1T> inline
00087 TypedFunctionFunctor1<RetT, RefCallArg<Arg1T> > osgTypedFunctionFunctor1Ref   (
00088     RetT (*pFunc)(Arg1T &))
00089 {
00090     TypedFunctionFunctor1<RetT, RefCallArg<Arg1T> > returnValue;
00091 
00092     returnValue.setMethod(pFunc);
00093 
00094     return returnValue;
00095 }
00096 
00097 
00098 template <class Arg1T> inline
00099 TypedFunctionVoidFunctor1< RefCallArg<Arg1T> > osgTypedFunctionVoidFunctor1Ref(
00100     void (*pFunc)(Arg1T &))
00101 {
00102     TypedFunctionVoidFunctor1< RefCallArg<Arg1T> > returnValue;
00103 
00104     returnValue.setMethod(pFunc);
00105 
00106     return returnValue;
00107 }
00108 
00109 
00110 //---------------------------------------------------------------------------
00111 //  osgTypedFunctionFunctor1CPtr
00112 //---------------------------------------------------------------------------
00113 
00114 template <class RetT, class Arg1T>
00115 inline TypedFunctionFunctor1<RetT, CPtrCallArg<Arg1T> >
00116 osgTypedFunctionFunctor1CPtr(RetT (*pFunc)(Arg1T))
00117 {
00118     TypedFunctionFunctor1<RetT, CPtrCallArg<Arg1T> > returnValue;
00119 
00120     returnValue.setMethod(pFunc);
00121 
00122     return returnValue;
00123 }
00124 
00125 template <class Arg1T> inline
00126 TypedFunctionVoidFunctor1< CPtrCallArg<Arg1T> >
00127     osgTypedFunctionVoidFunctor1CPtr(void (*pFunc)(Arg1T))
00128 {
00129     TypedFunctionVoidFunctor1< CPtrCallArg<Arg1T> > returnValue;
00130 
00131     returnValue.setMethod(pFunc);
00132 
00133     return returnValue;
00134 }
00135 
00136 
00137 //---------------------------------------------------------------------------
00138 //  osgTypedFunctionFunctor1CPtrRef
00139 //---------------------------------------------------------------------------
00140 
00141 
00142 template <class RetT, class Arg1T> inline
00143 TypedFunctionFunctor1<RetT, CPtrRefCallArg<Arg1T> >
00144     osgTypedFunctionFunctor1CPtrRef(RetT (*pFunc)(Arg1T &))
00145 {
00146     TypedFunctionFunctor1<RetT, CPtrRefCallArg<Arg1T> > returnValue;
00147 
00148     returnValue.setMethod(pFunc);
00149 
00150     return returnValue;
00151 }
00152 
00153 
00154 //---------------------------------------------------------------------------
00155 //  osgTypedFunctionVoidFunctor1CPtrRef
00156 //---------------------------------------------------------------------------
00157 
00158 
00159 template <class Arg1T> inline
00160 TypedFunctionVoidFunctor1< CPtrRefCallArg<Arg1T> >
00161     osgTypedFunctionVoidFunctor1CPtrRef(void (*pFunc)(Arg1T &))
00162 {
00163     TypedFunctionVoidFunctor1< CPtrRefCallArg<Arg1T> > returnValue;
00164 
00165     returnValue.setMethod(pFunc);
00166 
00167     return returnValue;
00168 }
00169 
00170 
00171 //---------------------------------------------------------------------------
00172 //  osgTypedMethodFunctor1Ref
00173 //---------------------------------------------------------------------------
00174 
00175 
00176 template <class RetT, class Arg1T> inline
00177 TypedObjectFunctor1<RetT, RefCallArg<Arg1T> > osgTypedMethodFunctor1Ref(
00178     RetT (Arg1T::*pFunc)())
00179 {
00180     typedef TypedObjectFunctor1<RetT, RefCallArg<Arg1T> > OFunctor;
00181 
00182     OFunctor returnValue;
00183 
00184     returnValue.setMethod(pFunc);
00185 
00186     return returnValue;
00187 }
00188 
00189 template <class Arg1T> inline
00190 TypedObjectVoidFunctor1< RefCallArg<Arg1T> > osgTypedMethodVoidFunctor1Ref(
00191     void (Arg1T::*pFunc)())
00192 {
00193     typedef TypedObjectVoidFunctor1< RefCallArg<Arg1T> > OFunctor;
00194 
00195     OFunctor returnValue;
00196 
00197     returnValue.setMethod(pFunc);
00198 
00199     return returnValue;
00200 }
00201 
00202 
00203 //---------------------------------------------------------------------------
00204 //  osgTypedMethodFunctor1Ptr
00205 //---------------------------------------------------------------------------
00206 
00207 
00208 template <class RetT, class Arg1T> inline
00209 TypedObjectFunctor1<RetT, PtrCallArg<Arg1T> > osgTypedMethodFunctor1Ptr(
00210     RetT (Arg1T::*pFunc)())
00211 {
00212     typedef TypedObjectFunctor1<RetT, PtrCallArg<Arg1T> > OFunctor;
00213 
00214     OFunctor returnValue;
00215 
00216     returnValue.setMethod(pFunc);
00217 
00218     return returnValue;
00219 }
00220 
00221 template <class Arg1T> inline
00222 TypedObjectVoidFunctor1< PtrCallArg<Arg1T> > osgTypedMethodVoidFunctor1Ptr(
00223     void (Arg1T::*pFunc)())
00224 {
00225     typedef TypedObjectVoidFunctor1< PtrCallArg<Arg1T> > OFunctor;
00226 
00227     OFunctor returnValue;
00228 
00229     returnValue.setMethod(pFunc);
00230 
00231     return returnValue;
00232 }
00233 
00234 
00235 //---------------------------------------------------------------------------
00236 //  osgTypedMethodFunctor1ObjPtr
00237 //---------------------------------------------------------------------------
00238 
00239 
00240 template <class RetT, class ObjectT, class Arg1T> inline
00241 TypedStoredObjectFunctor1<RetT,
00242                           PtrCallArg<ObjectT>,
00243                           PtrCallArg<Arg1T  > >
00244     osgTypedMethodFunctor1ObjPtr(      ObjectT  *pObj,
00245                                  RetT (ObjectT::*pFunc)(Arg1T *))
00246 {
00247     typedef TypedStoredObjectFunctor1<RetT,
00248                                       PtrCallArg<ObjectT>,
00249                                       PtrCallArg<Arg1T  > > OFunctor;
00250 
00251     OFunctor returnValue;
00252 
00253     returnValue.setMethod(pFunc);
00254     returnValue.setCalledObject(pObj);
00255 
00256     return returnValue;
00257 }
00258 
00259 
00260 template <class ObjectT, class Arg1T> inline
00261 TypedStoredObjectVoidFunctor1<PtrCallArg<ObjectT>,
00262                               PtrCallArg<Arg1T  > >
00263     osgTypedMethodVoidFunctor1ObjPtr(      ObjectT  *pObj,
00264                                      void (ObjectT::*pFunc)(Arg1T *))
00265 {
00266     typedef TypedStoredObjectVoidFunctor1<PtrCallArg<ObjectT>,
00267                                           PtrCallArg<Arg1T  > > OFunctor;
00268 
00269     OFunctor returnValue;
00270 
00271     returnValue.setMethod(pFunc);
00272     returnValue.setCalledObject(pObj);
00273 
00274     return returnValue;
00275 }
00276 
00277 
00278 //---------------------------------------------------------------------------
00279 //  osgTypedMethodFunctor1ObjPtrCPtrRef
00280 //---------------------------------------------------------------------------
00281 
00282 
00283 template <class RetT, class ObjectT, class Arg1T> inline
00284 TypedStoredObjectFunctor1<RetT,
00285                           PtrCallArg    <ObjectT>,
00286                           CPtrRefCallArg<Arg1T  > >
00287     osgTypedMethodFunctor1ObjPtrCPtrRef(      ObjectT  *pObj,
00288                                         RetT (ObjectT::*pFunc)(Arg1T &))
00289 {
00290     typedef TypedStoredObjectFunctor1<RetT,
00291                                       PtrCallArg    <ObjectT>,
00292                                       CPtrRefCallArg<Arg1T  > > OFunctor;
00293 
00294     OFunctor returnValue;
00295 
00296     returnValue.setMethod(pFunc);
00297     returnValue.setCalledObject(pObj);
00298 
00299     return returnValue;
00300 }
00301 
00302 
00303 template <class ObjectT, class Arg1T> inline
00304 TypedStoredObjectVoidFunctor1<PtrCallArg    <ObjectT>,
00305                               CPtrRefCallArg<Arg1T  > >
00306     osgTypedMethodVoidFunctor1ObjPtrCPtrRef(      ObjectT  *pObj,
00307                                             void (ObjectT::*pFunc)(Arg1T &))
00308 {
00309     typedef TypedStoredObjectVoidFunctor1<PtrCallArg    <ObjectT>,
00310                                           CPtrRefCallArg<Arg1T  > > OFunctor;
00311 
00312     OFunctor returnValue;
00313 
00314     returnValue.setMethod(pFunc);
00315     returnValue.setCalledObject(pObj);
00316 
00317     return returnValue;
00318 }
00319 
00320 
00321 //---------------------------------------------------------------------------
00322 //  osgTypedMethodFunctor1CPtr
00323 //---------------------------------------------------------------------------
00324 
00325 template <class RetT, class Arg1T>
00326 inline TypedObjectFunctor1<RetT, CPtrCallArg<Arg1T> >
00327 osgTypedMethodFunctor1CPtr(
00328     typename FunctorBuildFuncType1<RetT,
00329                                    CPtrCallArg<Arg1T> >::ObjFuncType pFunc)
00330 {
00331     typedef TypedObjectFunctor1<RetT, CPtrCallArg<Arg1T> > OFunctor;
00332 
00333     OFunctor returnValue;
00334 
00335     returnValue.setMethod(pFunc);
00336 
00337     return returnValue;
00338 }
00339 
00340 template <class Arg1T> inline
00341 TypedObjectVoidFunctor1< CPtrCallArg<Arg1T> >
00342     osgTypedMethodVoidFunctor1CPtr(
00343         typename FunctorBuildFuncType1<
00344             void, CPtrCallArg<Arg1T> >::ObjFuncType pFunc)
00345 {
00346     typedef TypedObjectVoidFunctor1< CPtrCallArg<Arg1T> > OFunctor;
00347 
00348     OFunctor returnValue;
00349 
00350     returnValue.setMethod(pFunc);
00351 
00352     return returnValue;
00353 }
00354 
00355 
00356 //---------------------------------------------------------------------------
00357 //  osgTypedMethodFunctor1CPtrRef
00358 //---------------------------------------------------------------------------
00359 
00360 
00361 template <class Arg1T> inline
00362 TypedObjectVoidFunctor1< CPtrRefCallArg<Arg1T> >
00363     osgTypedMethodVoidFunctor1CPtrRef(
00364         typename FunctorBuildFuncType1<
00365             void, CPtrRefCallArg<Arg1T> >::ObjFuncType pFunc)
00366 {
00367     typedef TypedObjectVoidFunctor1< CPtrRefCallArg<Arg1T> > OFunctor;
00368 
00369     OFunctor returnValue;
00370 
00371     returnValue.setMethod(pFunc);
00372 
00373     return returnValue;
00374 }
00375 
00376 
00377 //---------------------------------------------------------------------------
00378 //  osgTypedMethodFunctor1ObjCPtr
00379 //---------------------------------------------------------------------------
00380 
00381 
00382 template <class ObjectT, class Arg1T> inline
00383 TypedStoredObjectVoidFunctor1<
00384     CPtrCallArg<ObjectT>,
00385     CPtrCallArg<Arg1T  > > osgTypedMethodVoidFunctor1ObjCPtr(
00386 
00387              ObjectT                                              obj,
00388 
00389     typename TypedMethodVoidFunctor1ObjCPtrFGen<void,
00390                                                 ObjectT,
00391                                                 Arg1T  >::Func pFunc)
00392 
00393 {
00394     typedef TypedStoredObjectVoidFunctor1<CPtrCallArg<ObjectT>,
00395                                           CPtrCallArg<Arg1T  > > OFunctor;
00396 
00397     OFunctor returnValue;
00398 
00399     returnValue.setMethod      (pFunc);
00400     returnValue.setCalledObject(obj  );
00401 
00402     return returnValue;
00403 }
00404 
00405 
00406 //---------------------------------------------------------------------------
00407 //  osgTypedMethodFunctor1ObjCPtrRef
00408 //---------------------------------------------------------------------------
00409 
00410 
00411 template <class ObjectT, class Arg1T> inline
00412 TypedStoredObjectVoidFunctor1<
00413     CPtrRefCallArg<ObjectT>,
00414     CPtrRefCallArg<Arg1T  > > osgTypedMethodVoidFunctor1ObjCPtrRef(
00415 
00416              ObjectT                                              obj,
00417 
00418     typename TypedMethodVoidFunctor1ObjCPtrRefFGen<void,
00419                                                    ObjectT,
00420                                                    Arg1T  >::Func pFunc)
00421 
00422 {
00423     typedef TypedStoredObjectVoidFunctor1<CPtrRefCallArg<ObjectT>,
00424                                           CPtrRefCallArg<Arg1T  > > OFunctor;
00425 
00426     OFunctor returnValue;
00427 
00428     returnValue.setMethod      (pFunc);
00429     returnValue.setCalledObject(obj  );
00430 
00431     return returnValue;
00432 }
00433 
00434 
00435 //---------------------------------------------------------------------------
00436 //  osgTypedFunctionFunctor2Ptr
00437 //---------------------------------------------------------------------------
00438 
00439 
00440 template <class RetT, class ObjectT, class Arg2T> inline
00441 TypedFunctionFunctor2<RetT,
00442                       PtrCallArg<ObjectT>,
00443                       ArgsCollector<Arg2T> >
00444     osgTypedFunctionFunctor2Ptr    (RetT (*pFunc)(ObjectT *, Arg2T))
00445 {
00446     TypedFunctionFunctor2<RetT,
00447                           PtrCallArg   <ObjectT>,
00448                           ArgsCollector<Arg2T  > > returnValue;
00449 
00450     returnValue.setMethod(pFunc);
00451 
00452     return returnValue;
00453 }
00454 
00455 template <class ObjectT, class Arg2T> inline
00456 TypedFunctionVoidFunctor2<PtrCallArg <ObjectT>,
00457                           ArgsCollector<Arg2T> >
00458     osgTypedFunctionVoidFunctor2Ptr(void (*pFunc)(ObjectT *, Arg2T))
00459 {
00460     TypedFunctionVoidFunctor2<PtrCallArg   <ObjectT>,
00461                               ArgsCollector<Arg2T  > > returnValue;
00462 
00463     returnValue.setMethod(pFunc);
00464 
00465     return returnValue;
00466 }
00467 
00468 
00469 //---------------------------------------------------------------------------
00470 //  osgTypedFunctionFunctor2Ref
00471 //---------------------------------------------------------------------------
00472 
00473 
00474 template <class RetT, class ObjectT, class Arg2T> inline
00475 TypedFunctionFunctor2<RetT,
00476                       RefCallArg   <ObjectT>,
00477                       ArgsCollector<Arg2T  > >
00478     osgTypedFunctionFunctor2Ref    (RetT (*pFunc)(ObjectT &, Arg2T))
00479 {
00480     TypedFunctionFunctor2<RetT,
00481                           RefCallArg<ObjectT>,
00482                           ArgsCollector<Arg2T> > returnValue;
00483 
00484     returnValue.setMethod(pFunc);
00485 
00486     return returnValue;
00487 }
00488 
00489 template <class ObjectT, class Arg2T> inline
00490 TypedFunctionVoidFunctor2<RefCallArg   <ObjectT>,
00491                           ArgsCollector<Arg2T  > >
00492     osgTypedFunctionVoidFunctor2Ref(void (*pFunc)(ObjectT &, Arg2T))
00493 {
00494     TypedFunctionVoidFunctor2<RefCallArg<ObjectT>,
00495                               ArgsCollector<Arg2T> > returnValue;
00496 
00497     returnValue.setMethod(pFunc);
00498 
00499     return returnValue;
00500 }
00501 
00502 //---------------------------------------------------------------------------
00503 //  osgTypedFunctionFunctor2CPtr
00504 //---------------------------------------------------------------------------
00505 
00506 template <class RetT, class ObjectT, class Arg2T>
00507 inline TypedFunctionFunctor2<RetT, CPtrCallArg<ObjectT>, ArgsCollector<Arg2T> >
00508 osgTypedFunctionFunctor2CPtr    (RetT (*pFunc)(ObjectT, Arg2T))
00509 {
00510     TypedFunctionFunctor2<RetT,
00511                           CPtrCallArg<ObjectT>,
00512                           ArgsCollector<Arg2T> > returnValue;
00513 
00514     returnValue.setMethod(pFunc);
00515 
00516     return returnValue;
00517 }
00518 
00519 template <class ObjectT, class Arg2T>
00520 inline TypedFunctionVoidFunctor2<CPtrCallArg<ObjectT>, ArgsCollector<Arg2T> >
00521 osgTypedFunctionVoidFunctor2Cptr(void (*pFunc)(ObjectT, Arg2T))
00522 {
00523     TypedFunctionVoidFunctor2<CPtrCallArg<ObjectT>,
00524                               ArgsCollector<Arg2T> > returnValue;
00525 
00526     returnValue.setMethod(pFunc);
00527 
00528     return returnValue;
00529 }
00530 
00531 //---------------------------------------------------------------------------
00532 //  osgTypedFunctionFunctor2CPtrRef
00533 //---------------------------------------------------------------------------
00534 
00535 template <class RetT, class ObjectT, class Arg2T> inline
00536 TypedFunctionFunctor2<RetT,
00537                       CPtrRefCallArg <ObjectT>,
00538                       ArgsCollector  <Arg2T> >
00539     osgTypedFunctionFunctor2CPtrRef(RetT (*pFunc)(ObjectT &, Arg2T))
00540 {
00541     TypedFunctionFunctor2<RetT,
00542                           CPtrRefCallArg<ObjectT>,
00543                           ArgsCollector<Arg2T>   > returnValue;
00544 
00545     returnValue.setMethod(pFunc);
00546 
00547     return returnValue;
00548 }
00549 
00550 template <class ObjectT, class Arg2T> inline
00551 TypedFunctionVoidFunctor2<CPtrRefCallArg <ObjectT>,
00552                           ArgsCollector  <Arg2T> >
00553     osgTypedFunctionVoidFunctor2CPtrRef(void (*pFunc)(ObjectT &, Arg2T))
00554 {
00555     TypedFunctionVoidFunctor2<CPtrRefCallArg<ObjectT>,
00556                               ArgsCollector<Arg2T> > returnValue;
00557 
00558     returnValue.setMethod(pFunc);
00559 
00560     return returnValue;
00561 }
00562 
00563 
00564 //---------------------------------------------------------------------------
00565 //  osgTypedFunctionFunctor2Ref
00566 //---------------------------------------------------------------------------
00567 
00568 template <class RetT, class Arg1T, class Arg2T> inline
00569 TypedObjectFunctor2<RetT,
00570                     RefCallArg   <Arg1T>,
00571                     ArgsCollector<Arg2T> >
00572     osgTypedMethodFunctor2Ref(RetT (Arg1T::*pFunc)(Arg2T))
00573 {
00574     typedef TypedObjectFunctor2<RetT,
00575                                 RefCallArg   <Arg1T>,
00576                                 ArgsCollector<Arg2T> > OFunctor;
00577 
00578     OFunctor returnValue;
00579 
00580     returnValue.setMethod(pFunc);
00581 
00582     return returnValue;
00583 }
00584 
00585 template <class Arg1T, class Arg2T> inline
00586 TypedObjectVoidFunctor2<RefCallArg   <Arg1T>,
00587                         ArgsCollector<Arg2T> >
00588     osgTypedMethodVoidFunctor2Ref(void (Arg1T::*pFunc)(Arg2T))
00589 {
00590     typedef TypedObjectVoidFunctor2<RefCallArg   <Arg1T>,
00591                                     ArgsCollector<Arg2T> > OFunctor;
00592 
00593     OFunctor returnValue;
00594 
00595     returnValue.setMethod(pFunc);
00596 
00597     return returnValue;
00598 }
00599 
00600 
00601 //---------------------------------------------------------------------------
00602 //  osgTypedMethodFunctor2Ptr
00603 //---------------------------------------------------------------------------
00604 
00605 
00606 template <class RetT, class Arg1T, class Arg2T> inline
00607 TypedObjectFunctor2<RetT,
00608                     PtrCallArg   <Arg1T>,
00609                     ArgsCollector<Arg2T> >
00610     osgTypedMethodFunctor2Ptr(RetT (Arg1T::*pFunc)(Arg2T))
00611 {
00612     typedef TypedObjectFunctor2<RetT,
00613                                 PtrCallArg   <Arg1T>,
00614                                 ArgsCollector<Arg2T> > OFunctor;
00615 
00616     OFunctor returnValue;
00617 
00618     returnValue.setMethod(pFunc);
00619 
00620     return returnValue;
00621 }
00622 
00623 template <class Arg1T, class Arg2T> inline
00624 TypedObjectVoidFunctor2<PtrCallArg   <Arg1T>,
00625                         ArgsCollector<Arg2T> >
00626     osgTypedMethodVoidFunctor2Ptr(void (Arg1T::*pFunc)(Arg2T))
00627 {
00628     typedef TypedObjectVoidFunctor2<PtrCallArg   <Arg1T>,
00629                                     ArgsCollector<Arg2T> > OFunctor;
00630 
00631     OFunctor returnValue;
00632 
00633     returnValue.setMethod(pFunc);
00634 
00635     return returnValue;
00636 }
00637 
00638 
00639 //---------------------------------------------------------------------------
00640 //  osgTypedMethodFunctor2ObjPtr
00641 //---------------------------------------------------------------------------
00642 
00643 
00644 template <class RetT,  class ObjectT,
00645           class Arg1T, class Arg2T  > inline
00646 TypedStoredObjectFunctor2<RetT,
00647                           PtrCallArg   <ObjectT>,
00648                           PtrCallArg   <Arg1T  >,
00649                           ArgsCollector<Arg2T  > >
00650     osgTypedMethodFunctor2ObjPtr(      ObjectT  *pObj,
00651                                  RetT (ObjectT::*pFunc)(Arg1T *, Arg2T))
00652 {
00653     typedef TypedStoredObjectFunctor2<RetT,
00654                                       PtrCallArg   <ObjectT>,
00655                                       PtrCallArg   <Arg1T  >,
00656                                       ArgsCollector<Arg2T  > > OFunctor;
00657 
00658     OFunctor returnValue;
00659 
00660     returnValue.setMethod(pFunc);
00661     returnValue.setCalledObject(pObj);
00662 
00663     return returnValue;
00664 }
00665 
00666 template <class ObjectT, class Arg1T, class Arg2T> inline
00667 TypedStoredObjectVoidFunctor2<PtrCallArg   <ObjectT>,
00668                               PtrCallArg   <Arg1T  >,
00669                               ArgsCollector<Arg2T  > >
00670     osgTypedMethodVoidFunctor2ObjPtr(      ObjectT  *pObj,
00671                                      void (ObjectT::*pFunc)(Arg1T *, Arg2T))
00672 {
00673     typedef TypedStoredObjectVoidFunctor2<PtrCallArg   <ObjectT>,
00674                                           PtrCallArg   <Arg1T  >,
00675                                           ArgsCollector<Arg2T  > > OFunctor;
00676 
00677     OFunctor returnValue;
00678 
00679     returnValue.setMethod(pFunc);
00680     returnValue.setCalledObject(pObj);
00681 
00682     return returnValue;
00683 }
00684 
00685 
00686 //---------------------------------------------------------------------------
00687 //  osgTypedMethodFunctor2ObjPtrCPtrRef
00688 //---------------------------------------------------------------------------
00689 
00690 
00691 template <class RetT,  class ObjectT,
00692           class Arg1T, class Arg2T  > inline
00693 TypedStoredObjectFunctor2<RetT,
00694                           PtrCallArg    <ObjectT>,
00695                           CPtrRefCallArg<Arg1T  >,
00696                           ArgsCollector <Arg2T  > >
00697     osgTypedMethodFunctor2ObjPtrCPtrRef(
00698               ObjectT  *pObj,
00699         RetT (ObjectT::*pFunc)(Arg1T &, Arg2T))
00700 {
00701     typedef TypedStoredObjectFunctor2<RetT,
00702                                       PtrCallArg    <ObjectT>,
00703                                       CPtrRefCallArg<Arg1T  >,
00704                                       ArgsCollector <Arg2T  > > OFunctor;
00705 
00706     OFunctor returnValue;
00707 
00708     returnValue.setMethod(pFunc);
00709     returnValue.setCalledObject(pObj);
00710 
00711     return returnValue;
00712 }
00713 
00714 template <class ObjectT, class Arg1T, class Arg2T> inline
00715 TypedStoredObjectVoidFunctor2<PtrCallArg    <ObjectT>,
00716                               CPtrRefCallArg<Arg1T  >,
00717                               ArgsCollector <Arg2T  > >
00718     osgTypedMethodVoidFunctor2ObjPtrCPtrRef(
00719               ObjectT  *pObj,
00720         void (ObjectT::*pFunc)(Arg1T &, Arg2T))
00721 {
00722     typedef TypedStoredObjectVoidFunctor2<PtrCallArg    <ObjectT>,
00723                                           CPtrRefCallArg<Arg1T  >,
00724                                           ArgsCollector <Arg2T  > > OFunctor;
00725 
00726     OFunctor returnValue;
00727 
00728     returnValue.setMethod(pFunc);
00729     returnValue.setCalledObject(pObj);
00730 
00731     return returnValue;
00732 }
00733 
00734 //---------------------------------------------------------------------------
00735 //  osgTypedMethodFunctor2CPtr
00736 //---------------------------------------------------------------------------
00737 
00738 template <class RetT, class ObjectT, class Arg2T>
00739 inline TypedObjectFunctor2<RetT, CPtrCallArg<ObjectT>, ArgsCollector<Arg2T> >
00740 osgTypedMethodFunctor2CPtr(
00741     typename FunctorBuildFuncType2<RetT,
00742                                    CPtrCallArg<ObjectT>,
00743                                    ArgsCollector<Arg2T> >::ObjFuncType pFunc)
00744 {
00745     typedef TypedObjectFunctor2<RetT,
00746                                 CPtrCallArg<ObjectT>,
00747                                 ArgsCollector<Arg2T> > OFunctor;
00748 
00749     OFunctor returnValue;
00750 
00751     returnValue.setMethod(pFunc);
00752 
00753     return returnValue;
00754 }
00755 
00756 template <class ObjectT, class Arg2T>
00757 inline TypedObjectVoidFunctor2<CPtrCallArg<ObjectT>, ArgsCollector<Arg2T> >
00758 osgTypedMethodVoidFunctor2CPtr(
00759     typename FunctorBuildFuncType2<void,
00760                                    CPtrCallArg<ObjectT>,
00761                                    ArgsCollector<Arg2T> >::ObjFuncType pFunc)
00762 {
00763     typedef TypedObjectVoidFunctor2<CPtrCallArg<ObjectT>,
00764                                     ArgsCollector<Arg2T> > OFunctor;
00765 
00766     OFunctor returnValue;
00767 
00768     returnValue.setMethod(pFunc);
00769 
00770     return returnValue;
00771 }
00772 
00773 //---------------------------------------------------------------------------
00774 //  osgTypedMethodVoidFunctor2CPtrRef
00775 //---------------------------------------------------------------------------
00776 
00777 
00778 template <class ObjectT, class Arg1T> inline
00779 TypedObjectVoidFunctor2<CPtrRefCallArg<ObjectT>,
00780                         ArgsCollector <Arg1T  > >
00781     osgTypedMethodVoidFunctor2CPtrRef(
00782 
00783         typename FunctorBuildFuncType2<
00784             void,
00785             CPtrRefCallArg<ObjectT>,
00786             ArgsCollector <Arg1T  >   >::ObjFuncType pFunc)
00787 {
00788     typedef TypedObjectVoidFunctor2<CPtrRefCallArg<ObjectT>,
00789                                     ArgsCollector <Arg1T  > > OFunctor;
00790 
00791     OFunctor returnValue;
00792 
00793     returnValue.setMethod(pFunc);
00794 
00795     return returnValue;
00796 }
00797 
00798 
00799 //---------------------------------------------------------------------------
00800 //  osgTypedMethodFunctor2ObjCPtrPtr
00801 //---------------------------------------------------------------------------
00802 
00803 template <class ObjectT,
00804           class Arg1T,
00805           class Arg2T> inline
00806 TypedStoredObjectVoidFunctor2<CPtrRefCallArg<ObjectT>,
00807                               PtrCallArg    <Arg1T  >,
00808                               ArgsCollector <Arg2T  > >
00809     osgTypedMethodVoidFunctor2ObjCPtrPtr(
00810 
00811              ObjectT                                              &pObj,
00812 
00813     typename TypedMethodVoidFunctor2ObjCPtrPtrFGen<void,
00814                                                    ObjectT,
00815                                                    Arg1T,
00816                                                    Arg2T  >::Func  pFunc)
00817 {
00818     typedef TypedStoredObjectVoidFunctor2<CPtrRefCallArg<ObjectT>,
00819                                           PtrCallArg    <Arg1T  >,
00820                                           ArgsCollector <Arg2T  > > OFunctor;
00821 
00822     OFunctor returnValue;
00823 
00824     returnValue.setMethod      (pFunc);
00825     returnValue.setCalledObject(pObj);
00826 
00827     return returnValue;
00828 }
00829 
00830 
00831 //---------------------------------------------------------------------------
00832 //  osgTypedMethodFunctor2ObjCPtrRef
00833 //---------------------------------------------------------------------------
00834 
00835 template <class ObjectT,
00836           class Arg1T,
00837           class Arg2T> inline
00838 TypedStoredObjectVoidFunctor2<CPtrRefCallArg<ObjectT>,
00839                               CPtrRefCallArg<Arg1T  >,
00840                               ArgsCollector <Arg2T  > >
00841     osgTypedMethodVoidFunctor2ObjCPtrRef(
00842 
00843              ObjectT                                              &pObj,
00844 
00845     typename TypedMethodVoidFunctor2ObjCPtrRefFGen<void,
00846                                                    ObjectT,
00847                                                    Arg1T,
00848                                                    Arg2T  >::Func  pFunc)
00849 {
00850     typedef TypedStoredObjectVoidFunctor2<CPtrRefCallArg<ObjectT>,
00851                                           CPtrRefCallArg<Arg1T  >,
00852                                           ArgsCollector <Arg2T  > > OFunctor;
00853 
00854     OFunctor returnValue;
00855 
00856     returnValue.setMethod      (pFunc);
00857     returnValue.setCalledObject(pObj);
00858 
00859     return returnValue;
00860 }
00861 
00862 
00863 //---------------------------------------------------------------------------
00864 //  osgTypedMethodFunctor2BaseCPtrRef
00865 //---------------------------------------------------------------------------
00866 
00867 #ifdef __sgi
00868 #pragma set woff 1424
00869 #endif
00870 
00871 template <class RetT,  class ObjectT,
00872           class Arg1T, class Arg2T> inline
00873 TypedObjectFunctor2<RetT,
00874                     CPtrRefCallArg<Arg1T>,
00875                     ArgsCollector <Arg2T> >
00876     osgTypedMethodFunctor2BaseCPtrRef(
00877 
00878     typename TypedMethodFunctor2BaseCPtrRefFGen<RetT,
00879                                                 ObjectT,
00880                                                 Arg2T  >::Func pFunc)
00881 {
00882     typedef TypedObjectFunctor2<RetT,
00883                                 CPtrRefCallArg<Arg1T>,
00884                                 ArgsCollector <Arg2T> > OFunctor;
00885 
00886     typedef typename
00887         FunctorBuildObjFuncType1<RetT,
00888                                  CPtrRefCallArg<Arg1T>,
00889                                  ArgsCollector <Arg2T> >::ObjFuncType FuncT;
00890 
00891 
00892     OFunctor returnValue;
00893 
00894     returnValue.setMethod(reinterpret_cast<FuncT>(pFunc));
00895 
00896     return returnValue;
00897 }
00898 
00899 template <class RetT,  class ObjectT,
00900           class Arg1T, class Arg2T   >
00901 inline TypedObjectFunctor2<RetT, CPtrCallArg<Arg1T>, ArgsCollector<Arg2T> >
00902 osgTypedMethodFunctor2BaseCPtr(
00903     typename TypedMethodFunctor2BaseCPtrRefFGen<RetT,
00904                                                 ObjectT,
00905                                                 Arg2T   >::Func pFunc)
00906 {
00907     typedef TypedObjectFunctor2< RetT,
00908                                  CPtrCallArg  <Arg1T>,
00909                                  ArgsCollector<Arg2T> >              OFunctor;
00910 
00911     typedef typename
00912         FunctorBuildObjFuncType1<RetT,
00913                                  CPtrCallArg  <Arg1T>,
00914                                  ArgsCollector<Arg2T> >::ObjFuncType FuncT;
00915 
00916     OFunctor returnValue;
00917 
00918     returnValue.setMethod(reinterpret_cast<FuncT>(pFunc));
00919 
00920     return returnValue;
00921 }
00922 
00923 #ifdef __sgi
00924 #pragma reset woff 1424
00925 #endif
00926 
00927 OSG_END_NAMESPACE