src/AsyncFramework/AsyncCall.h

   1 /***************************************************************************
   2  *   Copyright (C) 2009, 2012 by Stefan Fuhrmann                           *
   3  *   stefanfuhrmann@alice-dsl.de                                           *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #pragma once
  22
  23 #include "JobBase.h"
  24 #include <functional>
  25 namespace async
  26 {
  27
  28 /**
  29  * Execute a call to a funtion returning @a void asynchronuously
  30  * in the background.
  31  *
  32  * Accepts a pointer to some free function or member function plus
  33  * parameters and schedules it for execution it in the given job scheduler.
  34  * If no scheduler is given, the default scheduler is used (see
  35  * \ref CJobScheduler::GetDefault for details).
  36  *
  37  * Instances of this class must be allocated dynamically and will be
  38  * deleted automatically immediately after function execution finished.
  39  *
  40  * Please note that the parameters must remain valid until the call
  41  * actually got executed. Therefore, only pointer and value parameter
  42  * are possible; reference parameters won't compile.
  43  */
  44
  45 class CAsyncCall : public CJobBase
  46 {
  47 private:
  48
  49     class ICall
  50     {
  51     public:
  52
  53         virtual ~ICall() {};
  54         virtual void Execute() = 0;
  55     };
  56
  57     class CCallStd : public ICall
  58     {
  59     private:
  60
  61         std::function<void()> func;
  62
  63     public:
  64
  65         CCallStd (std::function<void()> f)
  66             : func (f)
  67         {
  68         }
  69
  70         virtual void Execute() override
  71         {
  72             func();
  73         }
  74     };
  75
  76     class CCall0 : public ICall
  77     {
  78     private:
  79
  80         void (*func)();
  81
  82     public:
  83
  84         CCall0 (void (*func)())
  85             : func (func)
  86         {
  87         }
  88
  89         virtual void Execute() override
  90         {
  91             (*func)();
  92         }
  93     };
  94
  95     template<class C>
  96     class CCallMember0 : public ICall
  97     {
  98     private:
  99
 100         C* instance;
 101         void (C::*func)();
 102
 103     public:
 104
 105         CCallMember0 (C* instance, void (C::*func)())
 106             : instance (instance)
 107             , func (func)
 108         {
 109         }
 110
 111         virtual void Execute() override
 112         {
 113             (instance->*func)();
 114         }
 115     };
 116
 117     template<class T1>
 118     class CCall1 : public ICall
 119     {
 120     private:
 121
 122         T1 parameter1;
 123         void (*func)(T1);
 124
 125     public:
 126
 127         CCall1 (void (*func)(T1), T1 parameter1)
 128             : parameter1 (parameter1)
 129             , func (func)
 130         {
 131         }
 132
 133         virtual void Execute() override
 134         {
 135             (*func)(parameter1);
 136         }
 137     };
 138
 139     template<class C, class T1>
 140     class CCallMember1 : public ICall
 141     {
 142     private:
 143
 144         C* instance;
 145         T1 parameter1;
 146         void (C::*func)(T1);
 147
 148     public:
 149
 150         CCallMember1 (C* instance, void (C::*func)(T1), T1 parameter1)
 151             : instance (instance)
 152             , parameter1 (parameter1)
 153             , func (func)
 154         {
 155         }
 156
 157         virtual void Execute() override
 158         {
 159             (instance->*func)(parameter1);
 160         }
 161     };
 162
 163     template<class T1, class T2>
 164     class CCall2 : public ICall
 165     {
 166     private:
 167
 168         T1 parameter1;
 169         T2 parameter2;
 170         void (*func)(T1, T2);
 171
 172     public:
 173
 174         CCall2 (void (*func)(T1, T2), T1 parameter1, T2 parameter2)
 175             : parameter1 (parameter1)
 176             , parameter2 (parameter2)
 177             , func (func)
 178         {
 179         }
 180
 181         virtual void Execute() override
 182         {
 183             (*func)(parameter1, parameter2);
 184         }
 185     };
 186
 187     template<class C, class T1, class T2>
 188     class CCallMember2 : public ICall
 189     {
 190     private:
 191
 192         C* instance;
 193         T1 parameter1;
 194         T2 parameter2;
 195         void (C::*func)(T1, T2);
 196
 197     public:
 198
 199         CCallMember2 (C* instance, void (C::*func)(T1, T2), T1 parameter1, T2 parameter2)
 200             : instance (instance)
 201             , parameter1 (parameter1)
 202             , parameter2 (parameter2)
 203             , func (func)
 204         {
 205         }
 206
 207         virtual void Execute() override
 208         {
 209             (instance->*func)(parameter1, parameter2);
 210         }
 211     };
 212
 213     // result and actual "future"
 214
 215     ICall* call;
 216
 217     // actually execute the call
 218
 219     virtual void InternalExecute()
 220     {
 221         call->Execute();
 222     }
 223
 224 public:
 225
 226     // construct futures for all sorts of callable items
 227
 228     CAsyncCall (void (*func)(), CJobScheduler* scheduler = NULL)
 229         : call (NULL)
 230     {
 231         call = new CCall0 (func);
 232         Schedule (true, scheduler);
 233     }
 234
 235     CAsyncCall (std::function<void()> func, CJobScheduler* scheduler = NULL)
 236         : call (NULL)
 237     {
 238         call = new CCallStd (func);
 239         Schedule (true, scheduler);
 240     }
 241
 242     template<class C>
 243     CAsyncCall (C* instance, void (C::*func)(), CJobScheduler* scheduler = NULL)
 244         : call (NULL)
 245     {
 246         call = new CCallMember0<C>(instance, func);
 247         Schedule (true, scheduler);
 248     }
 249
 250     template<class T1>
 251     CAsyncCall (void (*func)(T1), T1 parameter1, CJobScheduler* scheduler = NULL)
 252         : call (NULL)
 253     {
 254         call = new CCall1<T1>(func, parameter1);
 255         Schedule (true, scheduler);
 256     }
 257
 258     template<class C, class T1>
 259     CAsyncCall (C* instance, void (C::*func)(T1), T1 parameter1, CJobScheduler* scheduler = NULL)
 260         : call (NULL)
 261     {
 262         call = new CCallMember1<C, T1>(instance, func, parameter1);
 263         Schedule (true, scheduler);
 264     }
 265
 266     template<class T1, class T2>
 267     CAsyncCall (void (*func)(T1,T2), T1 parameter1, T2 parameter2, CJobScheduler* scheduler = NULL)
 268         : call (NULL)
 269     {
 270         call = new CCall2<T1, T2>(func, parameter1, parameter2);
 271         Schedule (true, scheduler);
 272     }
 273
 274     template<class C, class T1, class T2>
 275     CAsyncCall (C* instance, void (C::*func)(T1,T2), T1 parameter1, T2 parameter2, CJobScheduler* scheduler = NULL)
 276         : call (NULL)
 277     {
 278         call = new CCallMember2<C, T1, T2>(instance, func, parameter1, parameter2);
 279         Schedule (true, scheduler);
 280     }
 281
 282     // cleanup
 283
 284     ~CAsyncCall()
 285     {
 286         delete call;
 287     }
 288 };
 289
 290 }