ReChannel: rc_member_func.h Source File

00001 // vim:set et sts=4 ts=4 tw=75 sw=4 ai ci cin cino=g0,t0:
00002 /*
00003  * Copyright (C) 2007, Technical Computer Science Group,
00004  *                     University of Bonn
00005  *
00006  * This file is part of the ReChannel library.
00007  *
00008  * The ReChannel library is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU General Public License as
00010  * published by the Free Software Foundation; either version 2 of the
00011  * License, or (at your option) any later version.
00012  *
00013  * This library is distributed in the hope that it will be
00014  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU General Public License
00019  * along with this library; see the file COPYING. If not, write to the
00020  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
00021  * Boston, MA 02110-1301, USA.
00022  *
00023  * Authors: Andreas Raabe and Armin Felke. Implementation by Armin Felke.
00024  *          {raabe, felke}@cs.uni-bonn.de
00025  */
00045 #ifndef RC_MEMBER_FUNC_H_
00046 #define RC_MEMBER_FUNC_H_
00047 
00048 namespace ReChannel {
00049 
00050 template<typename METHOD_PTR> struct rc_member_func;
00051 
00052 template<class R, class T>
00053 struct rc_member_func<R (T::*)()>
00054 {
00055     typedef R (T::*method_ptr_type)();
00056     rc_member_func(T& obj, method_ptr_type mp)
00057         : p_obj(obj), p_mp(mp)
00058         { }
00059     inline R operator()() const
00060         { return (p_obj.*p_mp)(); }
00061 private:
00062     T& p_obj;
00063     method_ptr_type p_mp;
00064 };
00065 
00066 template<class R, class T>
00067 struct rc_member_func<R (T::*)() const>
00068 {
00069     typedef R (T::*method_ptr_type)() const;
00070     rc_member_func(T& obj, method_ptr_type mp)
00071         : p_obj(obj), p_mp(mp)
00072         { }
00073     inline R operator()() const
00074         { return (p_obj.*p_mp)(); }
00075 private:
00076     T& p_obj;
00077     method_ptr_type p_mp;
00078 };
00079 
00080 template<class R, class T, class A1>
00081 struct rc_member_func<R (T::*)(A1)>
00082 {
00083     typedef R (T::*method_ptr_type)(A1);
00084     rc_member_func(T& obj, method_ptr_type mp)
00085         : p_obj(obj), p_mp(mp)
00086         { }
00087     inline R operator()(A1 a1) const
00088         { return (p_obj.*p_mp)(a1); }
00089 private:
00090     T& p_obj;
00091     method_ptr_type p_mp;
00092 };
00093 
00094 template<class R, class T, class A1>
00095 struct rc_member_func<R (T::*)(A1) const>
00096 {
00097     typedef R (T::*method_ptr_type)(A1) const;
00098     rc_member_func(T& obj, method_ptr_type mp)
00099         : p_obj(obj), p_mp(mp)
00100         { }
00101     inline R operator()(A1 a1) const
00102         { return (p_obj.*p_mp)(a1); }
00103 private:
00104     T& p_obj;
00105     method_ptr_type p_mp;
00106 };
00107 
00108 template<class R, class T, class A1, class A2>
00109 struct rc_member_func<R (T::*)(A1, A2)>
00110 {
00111     typedef R (T::*method_ptr_type)(A1, A2);
00112     rc_member_func(T& obj, method_ptr_type mp)
00113         : p_obj(obj), p_mp(mp)
00114         { }
00115     inline R operator()(A1 a1, A2 a2) const
00116         { return (p_obj.*p_mp)(a1, a2); }
00117 private:
00118     T& p_obj;
00119     method_ptr_type p_mp;
00120 };
00121 
00122 template<class R, class T, class A1, class A2>
00123 struct rc_member_func<R (T::*)(A1, A2) const>
00124 {
00125     typedef R (T::*method_ptr_type)(A1, A2) const;
00126     rc_member_func(T& obj, method_ptr_type mp)
00127         : p_obj(obj), p_mp(mp)
00128         { }
00129     inline R operator()(A1 a1, A2 a2) const
00130         { return (p_obj.*p_mp)(a1, a2); }
00131 private:
00132     T& p_obj;
00133     method_ptr_type p_mp;
00134 };
00135 
00136 template<class R, class T, class A1, class A2, class A3>
00137 struct rc_member_func<R (T::*)(A1, A2, A3)>
00138 {
00139     typedef R (T::*method_ptr_type)(A1, A2, A3);
00140     rc_member_func(T& obj, method_ptr_type mp)
00141         : p_obj(obj), p_mp(mp)
00142         { }
00143     inline R operator()(
00144         A1 a1, A2 a2, A3 a3) const
00145         { return (p_obj.*p_mp)(a1, a2, a3); }
00146 private:
00147     T& p_obj;
00148     method_ptr_type p_mp;
00149 };
00150 
00151 template<class R, class T, class A1, class A2, class A3>
00152 struct rc_member_func<R (T::*)(A1, A2, A3) const>
00153 {
00154     typedef R (T::*method_ptr_type)(A1, A2, A3) const;
00155     rc_member_func(T& obj, method_ptr_type mp)
00156         : p_obj(obj), p_mp(mp)
00157         { }
00158     inline R operator()(
00159         A1 a1, A2 a2, A3 a3) const
00160         { return (p_obj.*p_mp)(a1, a2, a3); }
00161 private:
00162     T& p_obj;
00163     method_ptr_type p_mp;
00164 };
00165 
00166 template<class R, class T, class A1, class A2, class A3, class A4>
00167 struct rc_member_func<R (T::*)(A1, A2, A3, A4)>
00168 {
00169     typedef R (T::*method_ptr_type)(A1, A2, A3, A4);
00170     rc_member_func(T& obj, method_ptr_type mp)
00171         : p_obj(obj), p_mp(mp)
00172         { }
00173     inline R operator()(A1 a1, A2 a2, A3 a3, A4 a4) const
00174         { return (p_obj.*p_mp)(a1, a2, a3, a4); }
00175 private:
00176     T& p_obj;
00177     method_ptr_type p_mp;
00178 };
00179 
00180 template<class R, class T, class A1, class A2, class A3, class A4>
00181 struct rc_member_func<R (T::*)(A1, A2, A3, A4) const>
00182 {
00183     typedef R (T::*method_ptr_type)(A1, A2, A3, A4) const;
00184     rc_member_func(T& obj, method_ptr_type mp)
00185         : p_obj(obj), p_mp(mp)
00186         { }
00187     inline R operator()(A1 a1, A2 a2, A3 a3, A4 a4) const
00188         { return (p_obj.*p_mp)(a1, a2, a3, a4); }
00189 private:
00190     T& p_obj;
00191     method_ptr_type p_mp;
00192 };
00193 
00194 template<class R, class T, class A1, class A2, class A3, class A4,
00195     class A5>
00196 struct rc_member_func<R (T::*)(A1, A2, A3, A4, A5)>
00197 {
00198     typedef R (T::*method_ptr_type)(A1, A2, A3, A4, A5);
00199     rc_member_func(T& obj, method_ptr_type mp)
00200         : p_obj(obj), p_mp(mp)
00201         { }
00202     inline R operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
00203         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5); }
00204 private:
00205     T& p_obj;
00206     method_ptr_type p_mp;
00207 };
00208 
00209 template<class R, class T, class A1, class A2, class A3, class A4,
00210     class A5>
00211 struct rc_member_func<R (T::*)(A1, A2, A3, A4, A5) const>
00212 {
00213     typedef R (T::*method_ptr_type)(A1, A2, A3, A4, A5) const;
00214     rc_member_func(T& obj, method_ptr_type mp)
00215         : p_obj(obj), p_mp(mp)
00216         { }
00217     inline R operator()(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
00218         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5); }
00219 private:
00220     T& p_obj;
00221     method_ptr_type p_mp;
00222 };
00223 
00224 template<class R, class T, class A1, class A2, class A3, class A4,
00225     class A5, class A6>
00226 struct rc_member_func<R (T::*)(A1, A2, A3, A4, A5, A6)>
00227 {
00228     typedef R (T::*method_ptr_type)(A1, A2, A3, A4, A5, A6);
00229     rc_member_func(T& obj, method_ptr_type mp)
00230         : p_obj(obj), p_mp(mp)
00231         { }
00232     inline R operator()(
00233         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
00234         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5, a6); }
00235 private:
00236     T& p_obj;
00237     method_ptr_type p_mp;
00238 };
00239 
00240 template<class R, class T, class A1, class A2, class A3, class A4,
00241     class A5, class A6>
00242 struct rc_member_func<R (T::*)(A1, A2, A3, A4, A5, A6) const>
00243 {
00244     typedef R (T::*method_ptr_type)(A1, A2, A3, A4, A5, A6) const;
00245     rc_member_func(T& obj, method_ptr_type mp)
00246         : p_obj(obj), p_mp(mp)
00247         { }
00248     inline R operator()(
00249         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
00250         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5, a6); }
00251 private:
00252     T& p_obj;
00253     method_ptr_type p_mp;
00254 };
00255 
00256 template<class R, class T, class A1, class A2, class A3, class A4,
00257     class A5, class A6, class A7>
00258 struct rc_member_func<R (T::*)(A1, A2, A3, A4, A5, A6, A7)>
00259 {
00260     typedef R (T::*method_ptr_type)(A1, A2, A3, A4, A5, A6, A7);
00261     rc_member_func(T& obj, method_ptr_type mp)
00262         : p_obj(obj), p_mp(mp)
00263         { }
00264     inline R operator()(
00265         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
00266         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5, a6, a7); }
00267 private:
00268     T& p_obj;
00269     method_ptr_type p_mp;
00270 };
00271 
00272 template<class R, class T, class A1, class A2, class A3, class A4,
00273     class A5, class A6, class A7>
00274 struct rc_member_func<R (T::*)(A1, A2, A3, A4, A5, A6, A7) const>
00275 {
00276     typedef R (T::*method_ptr_type)(A1, A2, A3, A4, A5, A6, A7) const;
00277     rc_member_func(T& obj, method_ptr_type mp)
00278         : p_obj(obj), p_mp(mp)
00279         { }
00280     inline R operator()(
00281         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
00282         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5, a6, a7); }
00283 private:
00284     T& p_obj;
00285     method_ptr_type p_mp;
00286 };
00287 
00288 template<class R, class T, class A1, class A2, class A3, class A4,
00289     class A5, class A6, class A7, class A8>
00290 struct rc_member_func<R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8)>
00291 {
00292     typedef R (T::*method_ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8);
00293     rc_member_func(T& obj, method_ptr_type mp)
00294         : p_obj(obj), p_mp(mp)
00295         { }
00296     inline R operator()(
00297         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
00298         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5, a6, a7, a8); }
00299 private:
00300     T& p_obj;
00301     method_ptr_type p_mp;
00302 };
00303 
00304 template<class R, class T, class A1, class A2, class A3, class A4,
00305     class A5, class A6, class A7, class A8>
00306 struct rc_member_func<R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8) const>
00307 {
00308     typedef R (T::*method_ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8) const;
00309     rc_member_func(T& obj, method_ptr_type mp)
00310         : p_obj(obj), p_mp(mp)
00311         { }
00312     inline R operator()(
00313         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
00314         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5, a6, a7, a8); }
00315 private:
00316     T& p_obj;
00317     method_ptr_type p_mp;
00318 };
00319 
00320 template<class R, class T, class A1, class A2, class A3, class A4,
00321     class A5, class A6, class A7, class A8, class A9>
00322 struct rc_member_func<R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
00323 {
00324     typedef R (T::*method_ptr_type)(A1, A2, A3, A4, A5, A6, A7, A8, A9);
00325     rc_member_func(T& obj, method_ptr_type mp)
00326         : p_obj(obj), p_mp(mp)
00327         { }
00328     inline R operator()(
00329         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8,
00330         A9 a9) const
00331         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5, a6, a7, a8, a9); }
00332 private:
00333     T& p_obj;
00334     method_ptr_type p_mp;
00335 };
00336 
00337 template<class R, class T, class A1, class A2, class A3, class A4,
00338     class A5, class A6, class A7, class A8, class A9>
00339 struct rc_member_func<R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const>
00340 {
00341     typedef R (T::*method_ptr_type)(
00342         A1, A2, A3, A4, A5, A6, A7, A8, A9) const;
00343     rc_member_func(T& obj, method_ptr_type mp)
00344         : p_obj(obj), p_mp(mp)
00345         { }
00346     inline R operator()(
00347         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8,
00348         A9 a9) const
00349         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5, a6, a7, a8, a9); }
00350 private:
00351     T& p_obj;
00352     method_ptr_type p_mp;
00353 };
00354 
00355 template<class R, class T, class A1, class A2, class A3, class A4,
00356     class A5, class A6, class A7, class A8, class A9, class A10>
00357 struct
00358 rc_member_func<R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
00359 {
00360     typedef R (T::*method_ptr_type)(
00361         A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
00362     rc_member_func(T& obj, method_ptr_type mp)
00363         : p_obj(obj), p_mp(mp)
00364         { }
00365     inline R operator()(
00366         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8,
00367         A9 a9, A10 a10) const
00368         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
00369 private:
00370     T& p_obj;
00371     method_ptr_type p_mp;
00372 };
00373 
00374 template<class R, class T, class A1, class A2, class A3, class A4,
00375     class A5, class A6, class A7, class A8, class A9, class A10>
00376 struct
00377 rc_member_func<R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const>
00378 {
00379     typedef R (T::*method_ptr_type)(
00380         A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const;
00381     rc_member_func(T& obj, method_ptr_type mp)
00382         : p_obj(obj), p_mp(mp)
00383         { }
00384     inline R operator()(
00385         A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8,
00386         A9 a9, A10 a10) const
00387         { return (p_obj.*p_mp)(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
00388 private:
00389     T& p_obj;
00390     method_ptr_type p_mp;
00391 };
00392 
00393 } // namespace ReChannel
00394 
00395 #endif // RC_MEMBER_FUNC_H_
00396 
00397 //
00398 // $Id: rc_member_func.h,v 1.3 2007/10/09 00:22:26 felke Exp $
00399 // $Source: /var/cvs/projekte/ReChannel-v2/src/ReChannel/util/rc_member_func.h,v $
00400 //
00401