git.cworth.org Git - vogl/blob - src/extlib/loki/include/loki/Function.h

   1 ////////////////////////////////////////////////////////////////////////////////
   2 // The Loki Library
   3 // Copyright (c) 2005 Peter Kümmel
   4 // Permission to use, copy, modify, distribute and sell this software for any
   5 //     purpose is hereby granted without fee, provided that the above copyright
   6 //     notice appear in all copies and that both that copyright notice and this
   7 //     permission notice appear in supporting documentation.
   8 // The author makes no representations about the
   9 //     suitability of this software for any purpose. It is provided "as is"
  10 //     without express or implied warranty.
  11 ////////////////////////////////////////////////////////////////////////////////
  12 #ifndef LOKI_FUNCTION_INC_
  13 #define LOKI_FUNCTION_INC_
  14
  15 // $Id: Function.h 841 2008-03-24 23:58:28Z rich_sposato $
  16
  17
  18 #define LOKI_ENABLE_FUNCTION
  19
  20 #include <stdexcept>
  21
  22 #include <loki/Functor.h>
  23 #include <loki/Sequence.h>
  24
  25 namespace Loki
  26 {
  27
  28 ////////////////////////////////////////////////////////////////////////////////
  29 ///  \struct Function
  30 ///
  31 ///  \ingroup FunctorGroup
  32 ///  Allows a boost/TR1 like usage of Functor.
  33 ///
  34 ///  \par Usage
  35 ///
  36 ///      - free functions: e.g.  \code Function<int(int,int)> f(&freeFunction);
  37 ///                              \endcode
  38 ///      - member functions: e.g \code Function<int()> f(&object,&ObjectType::memberFunction);
  39 ///                              \endcode
  40 ///
  41 ///  see also test/Function/FunctionTest.cpp (the modified test program from boost)
  42 ////////////////////////////////////////////////////////////////////////////////
  43
  44 template<class R = void()>
  45 struct Function;
  46
  47
  48 template<class R>
  49 struct Function<R()> : public Functor<R>
  50 {
  51     typedef Functor<R> FBase;
  52
  53     Function() : FBase() {}
  54
  55 Function(const Function &func) : FBase()
  56 {
  57         if( !func.empty())
  58                 FBase::operator=(func);
  59 }
  60
  61 // test on emptiness
  62 template<class R2>
  63 Function(Function<R2()> func) : FBase()
  64 {
  65         if(!func.empty())
  66                 FBase::operator=(func);
  67 }
  68
  69 // clear  by '= 0'
  70 Function(const int i) : FBase()
  71 {
  72         if(i==0)
  73                 FBase::clear();
  74         else
  75                 throw std::runtime_error("Loki::Function(const int i): i!=0");
  76 }
  77
  78 template<class Func>
  79 Function(Func func) : FBase(func) {}
  80
  81 template<class Host, class Func>
  82 Function(const Host &host, const Func &func) : FBase(host,func) {}
  83
  84 };
  85
  86
  87 ////////////////////////////////////////////////////////////////////////////////
  88 // macros for the repetitions
  89 ////////////////////////////////////////////////////////////////////////////////
  90
  91 #define LOKI_FUNCTION_BODY                          \
  92                                                     \
  93         Function() : FBase() {}                     \
  94                                                     \
  95         Function(const Function& func) : FBase()    \
  96         {                                           \
  97             if( !func.empty())                      \
  98                 FBase::operator=(func);             \
  99         }                                           \
 100                                                     \
 101         Function(const int i) : FBase()             \
 102         {                                           \
 103             if(i==0)                                \
 104                 FBase::clear();                     \
 105             else                                    \
 106                 throw std::runtime_error(           \
 107             "Loki::Function(const int i): i!=0");   \
 108         }                                           \
 109                                                     \
 110         template<class Func>                        \
 111         Function(Func func) : FBase(func) {}        \
 112                                                     \
 113         template<class Host, class Func>            \
 114         Function(const Host& host, const Func& func): FBase(host,func) {}
 115
 116
 117 #define LOKI_FUNCTION_R2_CTOR_BODY          \
 118                                             \
 119         : FBase()                           \
 120         {                                   \
 121             if(!func.empty())               \
 122                 FBase::operator=(func);     \
 123         }
 124
 125
 126 ////////////////////////////////////////////////////////////////////////////////
 127 // repetitions
 128 ////////////////////////////////////////////////////////////////////////////////
 129
 130 template<>
 131 struct Function<>
 132                 : public Loki::Functor<>
 133 {
 134         typedef Functor<> FBase;
 135
 136         template<class R2>
 137         Function(Function<R2()> func)
 138         LOKI_FUNCTION_R2_CTOR_BODY
 139
 140         LOKI_FUNCTION_BODY // if compilation breaks here then
 141         // Function.h was not included before
 142         // Functor.h, check your include order
 143         // or define LOKI_ENABLE_FUNCTION
 144 };
 145
 146 template<class R,class P01>
 147 struct Function<R(P01)>
 148 : public Loki::Functor<R, Seq<P01> >
 149 {
 150     typedef Functor<R, Seq<P01> > FBase;
 151
 152     template<class R2,class Q01>
 153     Function(Function<R2(Q01)> func)
 154     LOKI_FUNCTION_R2_CTOR_BODY
 155
 156     LOKI_FUNCTION_BODY
 157 };
 158
 159 template<class R,class P01,class P02>
 160 struct Function<R(P01,P02)>
 161 : public Functor<R, Seq<P01,P02> >
 162 {
 163     typedef Functor<R, Seq<P01,P02> > FBase;
 164
 165     template<class R2,class Q01, class Q02>
 166     Function(Function<R2(Q01,Q02)> func)
 167     LOKI_FUNCTION_R2_CTOR_BODY
 168
 169     LOKI_FUNCTION_BODY
 170 };
 171
 172 template<class R,class P01,class P02, class P03>
 173 struct Function<R(P01,P02,P03)>
 174 : public Functor<R, Seq<P01,P02,P03> >
 175 {
 176     typedef Functor<R, Seq<P01,P02,P03> > FBase;
 177
 178     template<class R2,class Q01, class Q02,class Q03>
 179     Function(Function<R2(Q01,Q02,Q03)> func)
 180     LOKI_FUNCTION_R2_CTOR_BODY
 181
 182     LOKI_FUNCTION_BODY
 183 };
 184
 185 template<class R,class P01,class P02, class P03,class P04>
 186 struct Function<R(P01,P02,P03,P04)>
 187 : public Functor<R, Seq<P01,P02,P03,P04> >
 188 {
 189     typedef Functor<R, Seq<P01,P02,P03,P04> > FBase;
 190
 191     template<class R2,class Q01,class Q02, class Q03,class Q04>
 192     Function(Function<R2(Q01,Q02,Q03,Q04)> func)
 193     LOKI_FUNCTION_R2_CTOR_BODY
 194
 195     LOKI_FUNCTION_BODY
 196 };
 197
 198 template<class R,class P01,class P02, class P03,class P04,class P05>
 199 struct Function<R(P01,P02,P03,P04,P05)>
 200 : public Functor<R, Seq<P01,P02,P03,P04,P05> >
 201 {
 202     typedef Functor<R, Seq<P01,P02,P03,P04,P05> > FBase;
 203
 204     template<class R2,class Q01,class Q02, class Q03,class Q04,class Q05>
 205     Function(Function<R2(Q01,Q02,Q03,Q04,Q05)> func)
 206     LOKI_FUNCTION_R2_CTOR_BODY
 207
 208     LOKI_FUNCTION_BODY
 209 };
 210
 211 template<class R,    class P01,class P02, class P03,class P04,class P05,
 212          class P06>
 213 struct Function<R(P01,P02,P03,P04,P05,P06)>
 214 : public Functor<R, Seq<P01,P02,P03,P04,P05,P06> >
 215 {
 216     typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06> > FBase;
 217
 218     template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
 219     class Q06>
 220     Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06)> func)
 221     LOKI_FUNCTION_R2_CTOR_BODY
 222
 223     LOKI_FUNCTION_BODY
 224 };
 225
 226 template<class R,    class P01,class P02, class P03,class P04,class P05,
 227          class P06,class P07>
 228 struct Function<R(P01,P02,P03,P04,P05,P06,P07)>
 229 : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07> >
 230 {
 231     typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07> > FBase;
 232
 233     template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
 234     class Q06,class Q07>
 235     Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07)> func)
 236     LOKI_FUNCTION_R2_CTOR_BODY
 237
 238     LOKI_FUNCTION_BODY
 239 };
 240
 241 template<class R,    class P01,class P02, class P03,class P04,class P05,
 242          class P06,class P07, class P08>
 243 struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08)>
 244 : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08> >
 245 {
 246     typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08> > FBase;
 247
 248     template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
 249     class Q06,class Q07, class Q08>
 250     Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08)> func)
 251     LOKI_FUNCTION_R2_CTOR_BODY
 252
 253     LOKI_FUNCTION_BODY
 254 };
 255
 256 template<class R,    class P01,class P02, class P03,class P04,class P05,
 257          class P06,class P07, class P08,class P09>
 258 struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09)>
 259 : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09> >
 260 {
 261     typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09    > > FBase;
 262
 263     template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
 264     class Q06,class Q07, class Q08,class Q09>
 265     Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09)> func)
 266     LOKI_FUNCTION_R2_CTOR_BODY
 267
 268     LOKI_FUNCTION_BODY
 269 };
 270
 271 template<class R,    class P01,class P02, class P03,class P04,class P05,
 272          class P06,class P07, class P08,class P09,class P10>
 273 struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10)>
 274 : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10> >
 275 {
 276     typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10> > FBase;
 277
 278     template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
 279     class Q06,class Q07, class Q08,class Q09,class Q10>
 280     Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10)> func)
 281     LOKI_FUNCTION_R2_CTOR_BODY
 282
 283     LOKI_FUNCTION_BODY
 284 };
 285
 286 template<class R,    class P01,class P02, class P03,class P04,class P05,
 287          class P06,class P07, class P08,class P09,class P10,
 288          class P11>
 289 struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11)>
 290 : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11> >
 291 {
 292     typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11> >FBase;
 293
 294     template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
 295     class Q06,class Q07, class Q08,class Q09,class Q10,
 296     class Q11>
 297     Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11)> func)
 298     LOKI_FUNCTION_R2_CTOR_BODY
 299
 300     LOKI_FUNCTION_BODY
 301 };
 302
 303 template<class R,    class P01,class P02, class P03,class P04,class P05,
 304          class P06,class P07, class P08,class P09,class P10,
 305          class P11,class P12>
 306 struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12)>
 307 : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12> >
 308 {
 309     typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12> > FBase;
 310
 311     template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
 312     class Q06,class Q07, class Q08,class Q09,class Q10,
 313     class Q11,class Q12>
 314     Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12)> func)
 315     LOKI_FUNCTION_R2_CTOR_BODY
 316
 317     LOKI_FUNCTION_BODY
 318 };
 319
 320 template<class R,    class P01,class P02, class P03,class P04,class P05,
 321          class P06,class P07, class P08,class P09,class P10,
 322          class P11,class P12, class P13>
 323 struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13)>
 324 : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13> >
 325 {
 326     typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13> > FBase;
 327
 328     template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
 329     class Q06,class Q07, class Q08,class Q09,class Q10,
 330     class Q11,class Q12, class Q13>
 331     Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12,Q13)> func)
 332     LOKI_FUNCTION_R2_CTOR_BODY
 333
 334     LOKI_FUNCTION_BODY
 335 };
 336
 337 template<class R,    class P01,class P02, class P03,class P04,class P05,
 338          class P06,class P07, class P08,class P09,class P10,
 339          class P11,class P12, class P13,class P14>
 340 struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14)>
 341 : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14> >
 342 {
 343     typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14> > FBase;
 344     template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
 345     class Q06,class Q07, class Q08,class Q09,class Q10,
 346     class Q11,class Q12, class Q13,class Q14>
 347     Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12,Q13,Q14)> func)
 348     LOKI_FUNCTION_R2_CTOR_BODY
 349
 350     LOKI_FUNCTION_BODY
 351 };
 352
 353 template<class R,    class P01,class P02, class P03,class P04,class P05,
 354          class P06,class P07, class P08,class P09,class P10,
 355          class P11,class P12, class P13,class P14,class P15>
 356 struct Function<R(P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14,P15)>
 357 : public Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14,P15> >
 358 {
 359     typedef Functor<R, Seq<P01,P02,P03,P04,P05,P06,P07,P08,P09,P10,P11,P12,P13,P14,P15> > FBase;
 360
 361     template<class R2,    class Q01,class Q02, class Q03,class Q04,class Q05,
 362     class Q06,class Q07, class Q08,class Q09,class Q10,
 363     class Q11,class Q12, class Q13,class Q14,class Q15>
 364     Function(Function<R2(Q01,Q02,Q03,Q04,Q05,Q06,Q07,Q08,Q09,Q10,Q11,Q12,Q13,Q14,Q15)> func)
 365     LOKI_FUNCTION_R2_CTOR_BODY
 366
 367     LOKI_FUNCTION_BODY
 368 };
 369
 370 }// namespace Loki
 371
 372 #endif // end file guardian
 373