Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages
Source » Base » Functors

OSGTypedFunctors2.h

Go to the documentation of this 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 #ifndef _OSGTYPEDFUNCTORS2_H_
00040 #define _OSGTYPEDFUNCTORS2_H_
00041 #ifdef __sgi
00042 #pragma once
00043 #endif
00044 
00045 //---------------------------------------------------------------------------
00046 //  Includes
00047 //---------------------------------------------------------------------------
00048 
00049 #include <OSGTypedFunctorBase.h>
00050 
00051 OSG_BEGIN_NAMESPACE
00052 
00053 //---------------------------------------------------------------------------
00054 //  Forward References
00055 //---------------------------------------------------------------------------
00056 
00057 //---------------------------------------------------------------------------
00058 //   Types
00059 //---------------------------------------------------------------------------
00060 
00061 //---------------------------------------------------------------------------
00062 //  Class
00063 //---------------------------------------------------------------------------
00064 
00069 template <class RetT, 
00070           class CallArgT,
00071           class ArgsT   > 
00072 struct TypedTraits2
00073 {
00074     typedef typename CallArgT::ObjType ObjType;
00075     typedef typename CallArgT::ArgType ArgType;
00076 
00077     typedef typename ArgsT::Arg1T      Arg1T;
00078 
00079     typedef typename
00080         FunctorBuildFuncType2<RetT, 
00081                               CallArgT, 
00082                               ArgsT   >::FuncFunctionType         FunctionF;
00083 
00084     typedef typename
00085         FunctorBuildFuncType2<RetT, CallArgT, ArgsT>::ObjFuncType ObjMethodF;
00086 
00087     static void callObjectMethodVoid(UInt8   *pData2, 
00088                                      ArgType  arg1, 
00089                                      Arg1T    arg2)
00090     {
00091         ObjMethodF  pFunc = *((ObjMethodF *) pData2);
00092         ObjType    *pObj  = CallArgT::getPtr(arg1); 
00093 
00094         (pObj->*pFunc)(arg2);
00095     }
00096 
00097     static RetT callObjectMethod(UInt8   *pData2, 
00098                                  ArgType  arg1, 
00099                                  Arg1T    arg2)
00100     {
00101         ObjMethodF  pFunc = *((ObjMethodF *) pData2);
00102         ObjType    *pObj  = CallArgT::getPtr(arg1); 
00103 
00104         return (pObj->*pFunc)(arg2);
00105     }
00106 };
00107 
00108 
00109 
00110 
00115 template <class RetT, 
00116           class StoredObjCallArgT,
00117           class CallArgT,
00118           class ArgsT> 
00119 struct TypedSOTraits2
00120 {
00121     typedef typename StoredObjCallArgT::ObjType  ObjType;
00122 
00123     typedef typename CallArgT::ArgType           ArgType;
00124 
00125     typedef typename StoredObjCallArgT::ArgType  SetObjectT;
00126     typedef          ObjType                    *StoredObjectT;
00127 
00128     typedef typename ArgsT::Arg1T                Arg2T;
00129 
00130     typedef typename
00131         FunctorBuildObjFuncType2<RetT, 
00132                                  StoredObjCallArgT,
00133                                  CallArgT,
00134                                  ArgsT            >::ObjFuncType ObjMethodF;
00135 
00136 
00137     static void setCalledObject(Char8 *pData, SetObjectT obj)
00138     {
00139         *((ObjType **) pData) = &(*obj);
00140     }
00141 
00142 
00143     static void callObjectMethodVoid(UInt8   *pData1, 
00144                                      UInt8   *pData2, 
00145                                      ArgType  arg1  ,
00146                                      Arg2T    arg2  )
00147     {
00148         StoredObjectT pObj  = *((StoredObjectT *) pData1);
00149 
00150         ObjMethodF    pFunc = *((ObjMethodF     *) pData2);
00151         
00152         (pObj->*pFunc)(arg1, arg2);
00153     }
00154 
00155     static RetT callObjectMethod(UInt8   *pData1, 
00156                                  UInt8   *pData2, 
00157                                  ArgType  arg1  ,
00158                                  Arg2T    arg2  )
00159     {
00160         StoredObjectT pObj  = *((StoredObjectT *) pData1);
00161 
00162         ObjMethodF    pFunc = *((ObjMethodF     *) pData2);
00163         
00164         return (pObj->*pFunc)(arg1, arg2);
00165     }
00166 };
00167 
00168 
00169 
00170 
00171 //---------------------------------------------------------------------------
00172 //  Class
00173 //---------------------------------------------------------------------------
00174 
00179 template <class RetT,
00180           class CallArgT,
00181           class ArgsT,
00182           class SizeTraitsT = DefaultFunctorSizeTraits>
00183 class TypedFunctor2Base : public TypedFunctorBase<SizeTraitsT>
00184 {
00185     /*==========================  PUBLIC  =================================*/
00186 
00187   public:
00188 
00189     /*---------------------------------------------------------------------*/
00193     typedef typename CallArgT::ArgType CallArgType;
00194     typedef typename ArgsT   ::Arg1T   Arg1Type;
00195 
00197     /*---------------------------------------------------------------------*/
00201     TypedFunctor2Base(void);
00202     TypedFunctor2Base(const TypedFunctor2Base &source);
00203 
00205     /*---------------------------------------------------------------------*/
00209     virtual ~TypedFunctor2Base(void); 
00210 
00212     /*---------------------------------------------------------------------*/
00216     virtual RetT call(CallArgType obj,
00217                       Arg1Type    arg1);
00218 
00220     /*---------------------------------------------------------------------*/
00224     void operator =(const TypedFunctor2Base &source);
00225 
00227     /*=========================  PROTECTED  ===============================*/
00228 
00229   protected:
00230 
00231     /*==========================  PRIVATE  ================================*/
00232 
00233   private:
00234 
00235     /*---------------------------------------------------------------------*/
00239     typedef TypedFunctorBase <                       SizeTraitsT> Inherited;
00240 
00241     typedef TypedFunctor2Base<RetT, CallArgT, ArgsT, SizeTraitsT> Self;
00242 
00244 };
00245 
00246 
00247 
00248 
00249 //---------------------------------------------------------------------------
00250 //  Class
00251 //---------------------------------------------------------------------------
00252 
00257 template <class CallArgT, 
00258           class ArgsT, 
00259           class SizeTraitsT = DefaultFunctorSizeTraits>
00260 class TypedVoidFunctor2Base : public TypedFunctorBase<SizeTraitsT>
00261 {
00262     /*==========================  PUBLIC  =================================*/
00263 
00264   public:
00265 
00266     /*---------------------------------------------------------------------*/
00270     typedef typename CallArgT::ArgType CallArgType;
00271     typedef typename ArgsT   ::Arg1T   Arg1Type;
00272 
00274     /*---------------------------------------------------------------------*/
00278     TypedVoidFunctor2Base(void);
00279     TypedVoidFunctor2Base(const TypedVoidFunctor2Base &source);
00280 
00282     /*---------------------------------------------------------------------*/
00286     virtual ~TypedVoidFunctor2Base(void); 
00287 
00289     /*---------------------------------------------------------------------*/
00293     virtual void call(CallArgType obj,
00294                       Arg1Type    arg1);
00295 
00297     /*---------------------------------------------------------------------*/
00301     void operator =(const TypedVoidFunctor2Base &source);
00302 
00304     /*=========================  PROTECTED  ===============================*/
00305 
00306   protected:
00307 
00308     /*==========================  PRIVATE  ================================*/
00309 
00310   private:
00311 
00312     /*---------------------------------------------------------------------*/
00316     typedef TypedFunctorBase     <                 SizeTraitsT> Inherited;
00317     
00318     typedef TypedVoidFunctor2Base<CallArgT, ArgsT, SizeTraitsT> Self;
00319     
00321 };
00322 
00323 
00324 
00325 
00326 //---------------------------------------------------------------------------
00327 //  Class
00328 //---------------------------------------------------------------------------
00329 
00334 template <class RetT, 
00335           class CallArgT, 
00336           class ArgsT,
00337           class SizeTraitsT = DefaultFunctorSizeTraits>
00338 class TypedFunctionFunctor2 : 
00339     public TypedFunctionFunctorBase<TypedFunctor2Base<RetT, 
00340                                                       CallArgT,
00341                                                       ArgsT,
00342                                                       SizeTraitsT>,
00343                                     TypedTraits2     <RetT, 
00344                                                       CallArgT,
00345                                                       ArgsT> >
00346 {
00347     /*==========================  PUBLIC  =================================*/
00348 
00349   public:
00350 
00351     /*---------------------------------------------------------------------*/
00355     typedef typename CallArgT::ArgType CallArgType;
00356     typedef typename ArgsT   ::Arg1T   Arg1;
00357 
00359     /*---------------------------------------------------------------------*/
00363     TypedFunctionFunctor2(void);
00364     TypedFunctionFunctor2(const TypedFunctionFunctor2 &source);
00365     
00367     /*---------------------------------------------------------------------*/
00371     virtual ~TypedFunctionFunctor2(void); 
00372 
00374     /*---------------------------------------------------------------------*/
00378     virtual RetT call(CallArgType obj, 
00379                       Arg1        oArg1);
00380 
00382     /*=========================  PROTECTED  ===============================*/
00383 
00384   protected:
00385 
00386     /*==========================  PRIVATE  ================================*/
00387 
00388   private:
00389 
00390     /*---------------------------------------------------------------------*/
00394     typedef TypedTraits2<RetT, CallArgT, ArgsT> TypeTraits;
00395 
00396     typedef 
00397         TypedFunctionFunctorBase<TypedFunctor2Base<RetT, 
00398                                                    CallArgT,
00399                                                    ArgsT,
00400                                                    SizeTraitsT>,
00401                                  TypedTraits2     <RetT, 
00402                                                    CallArgT,
00403                                                    ArgsT>     > Inherited;
00404 
00405     typedef 
00406         TypedFunctionFunctor2   <RetT,
00407                                  CallArgT,
00408                                  ArgsT,
00409                                  SizeTraitsT                  > Self;
00410 
00412     /*---------------------------------------------------------------------*/
00417     void operator =(const TypedFunctionFunctor2 &source);
00418 
00420 };
00421 
00432 //---------------------------------------------------------------------------
00433 //  Class
00434 //---------------------------------------------------------------------------
00435 
00440 template <class CallArgT, 
00441           class ArgsT,
00442           class SizeTraitsT = DefaultFunctorSizeTraits>
00443 class TypedFunctionVoidFunctor2 : 
00444     public TypedFunctionFunctorBase<TypedVoidFunctor2Base<CallArgT,
00445                                                           ArgsT,
00446                                                           SizeTraitsT>,
00447                                     TypedTraits2         <void, 
00448                                                           CallArgT,
00449                                                           ArgsT> >
00450 {
00451     /*==========================  PUBLIC  =================================*/
00452 
00453   public:
00454 
00455     /*---------------------------------------------------------------------*/
00459     typedef typename CallArgT::ArgType CallArgType;
00460     typedef typename ArgsT   ::Arg1T   Arg1;
00461 
00463     /*---------------------------------------------------------------------*/
00467     TypedFunctionVoidFunctor2(void);
00468     TypedFunctionVoidFunctor2(const TypedFunctionVoidFunctor2 &source);
00469 
00471     /*---------------------------------------------------------------------*/
00475     virtual ~TypedFunctionVoidFunctor2(void); 
00476 
00478     /*---------------------------------------------------------------------*/
00482     virtual void call(CallArgType obj,
00483                       Arg1        oArg1);
00484 
00486     /*=========================  PROTECTED  ===============================*/
00487 
00488   protected:
00489 
00490     /*==========================  PRIVATE  ================================*/
00491 
00492   private:
00493 
00494     /*---------------------------------------------------------------------*/
00498     typedef TypedTraits2<void, CallArgT, ArgsT> TypeTraits;
00499 
00500     typedef 
00501         TypedFunctionFunctorBase <TypedVoidFunctor2Base<CallArgT,
00502                                                         ArgsT,
00503                                                         SizeTraitsT>,
00504                                   TypedTraits2         <void, 
00505                                                         CallArgT,
00506                                                         ArgsT>     > Inherited;
00507 
00508     typedef
00509         TypedFunctionVoidFunctor2<CallArgT,
00510                                   ArgsT,
00511                                   SizeTraitsT                      > Self;
00512 
00514     /*---------------------------------------------------------------------*/
00519     void operator =(const TypedFunctionVoidFunctor2 &source);
00520 
00522 };
00523 
00533 //---------------------------------------------------------------------------
00534 //  Class
00535 //---------------------------------------------------------------------------
00536 
00541 template <class RetT, 
00542           class CallArgT,
00543           class ArgsT,
00544           class SizeTraitsT = DefaultFunctorSizeTraits>
00545 class TypedObjectFunctor2 : 
00546     public TypedObjectFunctorBase<TypedFunctor2Base<RetT, 
00547                                                     CallArgT,
00548                                                     ArgsT,
00549                                                     SizeTraitsT>,
00550                                   TypedTraits2     <RetT, 
00551                                                     CallArgT,
00552                                                     ArgsT> >
00553 {
00554     /*==========================  PUBLIC  =================================*/
00555 
00556   public:
00557 
00558     /*---------------------------------------------------------------------*/
00562     typedef typename CallArgT::ArgType CallArgType;
00563     typedef typename ArgsT   ::Arg1T   Arg1;
00564 
00566     /*---------------------------------------------------------------------*/
00570     TypedObjectFunctor2(void);
00571     TypedObjectFunctor2(const TypedObjectFunctor2 &source);
00572 
00574     /*---------------------------------------------------------------------*/
00578     virtual ~TypedObjectFunctor2(void); 
00579 
00581     /*---------------------------------------------------------------------*/
00585     virtual RetT call(CallArgType obj,
00586                       Arg1        oArg1);
00587 
00589     /*=========================  PROTECTED  ===============================*/
00590 
00591   protected:
00592 
00593     /*==========================  PRIVATE  ================================*/
00594 
00595   private:
00596 
00597     /*---------------------------------------------------------------------*/
00601     typedef TypedTraits2<RetT, CallArgT, ArgsT> TypeTraits;
00602 
00603     typedef 
00604         TypedObjectFunctorBase<
00605             TypedFunctor2Base<RetT, 
00606                               CallArgT,
00607                               ArgsT,
00608                               SizeTraitsT>,
00609             TypedTraits2     <RetT, 
00610                               CallArgT,
00611                               ArgsT>   > Inherited;
00612 
00613     typedef
00614         TypedObjectFunctor2<RetT,
00615                             CallArgT,
00616                             ArgsT,
00617                             SizeTraitsT> Self;
00618 
00620     /*---------------------------------------------------------------------*/
00625     void operator =(const TypedObjectFunctor2 &source);
00626 
00628 };
00629 
00641 //---------------------------------------------------------------------------
00642 //  Class
00643 //---------------------------------------------------------------------------
00644 
00649 template <class CallArgT, 
00650           class ArgsT,
00651           class SizeTraitsT = DefaultFunctorSizeTraits>
00652 class TypedObjectVoidFunctor2 : 
00653     public TypedObjectFunctorBase<TypedVoidFunctor2Base<CallArgT, 
00654                                                         ArgsT,
00655                                                         SizeTraitsT>,
00656                                   TypedTraits2         <void, 
00657                                                         CallArgT,
00658                                                         ArgsT> >
00659 {
00660     /*==========================  PUBLIC  =================================*/
00661 
00662   public:
00663 
00664     /*---------------------------------------------------------------------*/
00668     typedef typename CallArgT::ArgType CallArgType;
00669     typedef typename ArgsT   ::Arg1T   Arg1;
00670 
00672     /*---------------------------------------------------------------------*/
00676     TypedObjectVoidFunctor2(void);
00677     TypedObjectVoidFunctor2(const TypedObjectVoidFunctor2 &source);
00678     
00680     /*---------------------------------------------------------------------*/
00684     virtual ~TypedObjectVoidFunctor2(void); 
00685 
00687     /*---------------------------------------------------------------------*/
00691     virtual void call(CallArgType obj,
00692                       Arg1        oArg1);
00693 
00695     /*=========================  PROTECTED  ===============================*/
00696 
00697   protected:
00698 
00699     /*==========================  PRIVATE  ================================*/
00700 
00701   private:
00702 
00703     /*---------------------------------------------------------------------*/
00707     typedef TypedTraits2<void, CallArgT, ArgsT> TypeTraits;
00708 
00709     typedef 
00710         TypedObjectFunctorBase<
00711             TypedVoidFunctor2Base<CallArgT,
00712                                   ArgsT,
00713                                   SizeTraitsT>,
00714             TypedTraits2         <void, 
00715                                   CallArgT,
00716                                   ArgsT>     > Inherited;
00717 
00718     typedef
00719         TypedObjectVoidFunctor2  <CallArgT,
00720                                   ArgsT,
00721                                   SizeTraitsT> Self;
00722 
00724     /*---------------------------------------------------------------------*/
00729     void operator =(const TypedObjectVoidFunctor2 &source);
00730 
00732 };
00733 
00744 //---------------------------------------------------------------------------
00745 //  Class
00746 //---------------------------------------------------------------------------
00747 
00752 template <class RetT, 
00753           class StoredObjectT,
00754           class ArgObjectT,
00755           class ArgsT,
00756           class SizeTraitsT = DefaultFunctorSizeTraits>
00757 class TypedStoredObjectFunctor2 : 
00758     public TypedStoredObjectFunctorBase<TypedFunctor2Base<RetT, 
00759                                                           ArgObjectT,
00760                                                           ArgsT,
00761                                                           SizeTraitsT>,
00762                                         TypedSOTraits2   <RetT, 
00763                                                           StoredObjectT,
00764                                                  typename ArgObjectT::ArgsC,
00765                                                           ArgsT> >
00766 {
00767     /*==========================  PUBLIC  =================================*/
00768 
00769   public:
00770 
00771     /*---------------------------------------------------------------------*/
00775     typedef typename ArgObjectT::ArgType CallArgType;
00776     typedef typename ArgsT     ::Arg1T   Arg1;
00777 
00779     /*---------------------------------------------------------------------*/
00783     TypedStoredObjectFunctor2(void);
00784     TypedStoredObjectFunctor2(const TypedStoredObjectFunctor2 &source);
00785     
00787     /*---------------------------------------------------------------------*/
00791     virtual ~TypedStoredObjectFunctor2(void); 
00792 
00794     /*---------------------------------------------------------------------*/
00798     virtual RetT call(CallArgType obj,
00799                       Arg1        oArg1);
00800 
00802     /*=========================  PROTECTED  ===============================*/
00803 
00804   protected:
00805 
00806     /*==========================  PRIVATE  ================================*/
00807 
00808   private:
00809 
00810     /*---------------------------------------------------------------------*/
00814     typedef TypedSOTraits2<RetT, 
00815                            StoredObjectT,
00816                            typename ArgObjectT::ArgsC,
00817                            ArgsT            > TypeSOTraits; 
00818 
00819     typedef 
00820         TypedStoredObjectFunctorBase<
00821             TypedFunctor2Base<RetT, 
00822                               ArgObjectT, 
00823                               ArgsT, 
00824                               SizeTraitsT>,
00825             TypedSOTraits2   <RetT, 
00826                               StoredObjectT,
00827                               typename ArgObjectT::ArgsC,
00828                               ArgsT            >        > Inherited;
00829 
00830     typedef
00831         TypedStoredObjectFunctor2<RetT, 
00832                                   StoredObjectT,
00833                                   ArgObjectT,
00834                                   ArgsT,
00835                                   SizeTraitsT           > Self;
00836 
00838     /*---------------------------------------------------------------------*/
00843     void operator =(const TypedStoredObjectFunctor2 &source);
00844 
00846 };
00847 
00860 //---------------------------------------------------------------------------
00861 //  Class
00862 //---------------------------------------------------------------------------
00863 
00868 template <class StoredObjectT, 
00869           class ArgObjectT,
00870           class ArgsT,
00871           class SizeTraitsT = DefaultFunctorSizeTraits>
00872 class TypedStoredObjectVoidFunctor2 : 
00873     public TypedStoredObjectFunctorBase<TypedVoidFunctor2Base<ArgObjectT,
00874                                                               ArgsT,
00875                                                               SizeTraitsT>,
00876                                         TypedSOTraits2      <void, 
00877                                                              StoredObjectT,
00878                                                     typename ArgObjectT::ArgsC,
00879                                                              ArgsT> >
00880 {
00881     /*==========================  PUBLIC  =================================*/
00882 
00883   public:
00884 
00885     /*---------------------------------------------------------------------*/
00889     typedef typename ArgsT     ::Arg1T   Arg1;
00890     typedef typename ArgObjectT::ArgType CallArgType;
00891 
00893     /*---------------------------------------------------------------------*/
00897     TypedStoredObjectVoidFunctor2(void);
00898     TypedStoredObjectVoidFunctor2(const TypedStoredObjectVoidFunctor2 &source);
00899     
00901     /*---------------------------------------------------------------------*/
00905     virtual ~TypedStoredObjectVoidFunctor2(void); 
00906 
00908     /*---------------------------------------------------------------------*/
00912     virtual void call(CallArgType obj,
00913                       Arg1        oArg1);
00914 
00916     /*=========================  PROTECTED  ===============================*/
00917 
00918   protected:
00919 
00920     /*==========================  PRIVATE  ================================*/
00921 
00922   private:
00923 
00924     /*---------------------------------------------------------------------*/
00928     typedef TypedSOTraits2<void, 
00929                            StoredObjectT,
00930                            typename ArgObjectT::ArgsC,
00931                            ArgsT                     > TypeSOTraits;
00932     typedef 
00933         TypedStoredObjectFunctorBase<
00934             TypedVoidFunctor2Base<ArgObjectT,
00935                                   ArgsT,
00936                                   SizeTraitsT>,
00937             TypedSOTraits2       <void, 
00938                                   StoredObjectT,
00939                                   typename ArgObjectT::ArgsC,
00940                                   ArgsT                     > > Inherited;
00941 
00942     typedef 
00943         TypedStoredObjectVoidFunctor2<StoredObjectT, 
00944                                       ArgObjectT,
00945                                       ArgsT,
00946                                       SizeTraitsT             > Self;
00947 
00949     /*---------------------------------------------------------------------*/
00954     void operator =(const TypedStoredObjectVoidFunctor2 &source);
00955 
00957 };
00958 
00969 OSG_END_NAMESPACE
00970 
00971 #include <OSGTypedFunctors2.inl>
00972 
00973 #endif /* _OSGTYPEDFUNCTORS2_HPP_ */
00974 
00975 
00976 
00977 
00978
Generated on Thu Aug 25 04:11:55 2005 for OpenSG by  doxygen 1.4.3