csutil/compositefunctor.h Source File (Crystal Space 2.0 Public API Reference)

| ## Public API Reference

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

csutil/compositefunctor.h

    00001 /*
    00002   Copyright (C) 2007 by Marten Svanfeldt
    00003
    00004   This library is free software; you can redistribute it and/or
    00005   modify it under the terms of the GNU Library General Public
    00006   License as published by the Free Software Foundation; either
    00007   version 2 of the License, or (at your option) any later version.
    00008
    00009   This library is distributed in the hope that it will be useful,
    00010   but WITHOUT ANY WARRANTY; without even the implied warranty of
    00011   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00012   Library General Public License for more details.
    00013
    00014   You should have received a copy of the GNU Library General Public
    00015   License along with this library; if not, write to the Free
    00016   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    00017 */
    00018
    00019 #ifndef __CS_CSUTIL_COMPOSITEFUNCTOR_H__
    00020 #define __CS_CSUTIL_COMPOSITEFUNCTOR_H__
    00021
    00022 namespace CS
    00023 {
    00024 namespace Meta
    00025 {
    00026
    00027   template<typename Fn1, typename Fn2>
    00028   class CompositeFunctorType2
    00029   {
    00030   public:
    00031     CompositeFunctorType2 (Fn1& fn1, Fn2& fn2)
    00032       : fn1 (fn1), fn2 (fn2)
    00033     {}
    00034
    00035     void operator() ()
    00036     {
    00037       fn1();
    00038       fn2();
    00039     }
    00040
    00041     template<typename A1>
    00042     void operator() (A1& a1)
    00043     {
    00044       fn1(a1);
    00045       fn2(a1);
    00046     }
    00047
    00048     template<typename A1, typename A2>
    00049     void operator() (A1& a1, A2& a2)
    00050     {
    00051       fn1(a1, a2);
    00052       fn2(a1, a2);
    00053     }
    00054
    00055     template<typename A1, typename A2, typename A3>
    00056     void operator() (A1& a1, A2& a2, A3& a3)
    00057     {
    00058       fn1(a1, a2, a3);
    00059       fn2(a1, a2, a3);
    00060     }
    00061
    00062     template<typename A1, typename A2, typename A3, typename A4>
    00063     void operator() (A1& a1, A2& a2, A3& a3, A4& a4)
    00064     {
    00065       fn1(a1, a2, a3, a4);
    00066       fn2(a1, a2, a3, a4);
    00067     }
    00068
    00069   private:
    00070     Fn1& fn1;
    00071     Fn2& fn2;
    00072   };
    00073
    00074   template<typename Fn1, typename Fn2, typename Fn3>
    00075   class CompositeFunctorType3
    00076   {
    00077   public:
    00078     CompositeFunctorType3 (Fn1& fn1, Fn2& fn2, Fn3& fn3)
    00079       : fn1 (fn1), fn2 (fn2), fn3 (fn3)
    00080     {}
    00081
    00082     void operator() ()
    00083     {
    00084       fn1();
    00085       fn2();
    00086       fn3();
    00087     }
    00088
    00089     template<typename A1>
    00090     void operator() (A1& a1)
    00091     {
    00092       fn1(a1);
    00093       fn2(a1);
    00094       fn3(a1);
    00095     }
    00096
    00097     template<typename A1, typename A2>
    00098     void operator() (A1& a1, A2& a2)
    00099     {
    00100       fn1(a1, a2);
    00101       fn2(a1, a2);
    00102       fn3(a1, a2);
    00103     }
    00104
    00105     template<typename A1, typename A2, typename A3>
    00106     void operator() (A1& a1, A2& a2, A3& a3)
    00107     {
    00108       fn1(a1, a2, a3);
    00109       fn2(a1, a2, a3);
    00110       fn3(a1, a2, a3);
    00111     }
    00112
    00113     template<typename A1, typename A2, typename A3, typename A4>
    00114     void operator() (A1& a1, A2& a2, A3& a3, A4& a4)
    00115     {
    00116       fn1(a1, a2, a3, a4);
    00117       fn2(a1, a2, a3, a4);
    00118       fn3(a1, a2, a3, a4);
    00119     }
    00120
    00121   private:
    00122     Fn1& fn1;
    00123     Fn2& fn2;
    00124     Fn3& fn3;
    00125   };
    00126
    00127   template<typename Fn1, typename Fn2>
    00128   CompositeFunctorType2<Fn1, Fn2> CompositeFunctor (Fn1& fn1, Fn2& fn2)
    00129   {
    00130     return CompositeFunctorType2<Fn1, Fn2> (fn1, fn2);
    00131   }
    00132
    00133   template<typename Fn1, typename Fn2, typename Fn3>
    00134   CompositeFunctorType3<Fn1, Fn2, Fn3> CompositeFunctor (Fn1& fn1, Fn2& fn2, Fn3& fn3)
    00135   {
    00136     return CompositeFunctorType3<Fn1, Fn2, Fn3> (fn1, fn2, fn3);
    00137   }
    00138 }
    00139 }
    00140
    00141 #endif