Thread.inl
00001 
00002 //
00003 // SFML - Simple and Fast Multimedia Library
00004 // Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
00005 //
00006 // This software is provided 'as-is', without any express or implied warranty.
00007 // In no event will the authors be held liable for any damages arising from the use of this software.
00008 //
00009 // Permission is granted to anyone to use this software for any purpose,
00010 // including commercial applications, and to alter it and redistribute it freely,
00011 // subject to the following restrictions:
00012 //
00013 // 1. The origin of this software must not be misrepresented;
00014 //    you must not claim that you wrote the original software.
00015 //    If you use this software in a product, an acknowledgment
00016 //    in the product documentation would be appreciated but is not required.
00017 //
00018 // 2. Altered source versions must be plainly marked as such,
00019 //    and must not be misrepresented as being the original software.
00020 //
00021 // 3. This notice may not be removed or altered from any source distribution.
00022 //
00024 
00025 namespace priv
00026 {
00027 // Base class for abstract thread functions
00028 struct ThreadFunc
00029 {
00030     virtual ~ThreadFunc() {}
00031     virtual void Run() = 0;
00032 };
00033 
00034 // Specialization using a functor (including free functions) with no argument
00035 template <typename T>
00036 struct ThreadFunctor : ThreadFunc
00037 {
00038     ThreadFunctor(T functor) : myFunctor(functor) {}
00039     virtual void Run() {myFunctor();}
00040     T myFunctor;
00041 };
00042 
00043 // Specialization using a functor (including free functions) with one argument
00044 template <typename F, typename A>
00045 struct ThreadFunctorWithArg : ThreadFunc
00046 {
00047     ThreadFunctorWithArg(F function, A arg) : myFunction(function), myArg(arg) {}
00048     virtual void Run() {myFunction(myArg);}
00049     F myFunction;
00050     A myArg;
00051 };
00052 
00053 // Specialization using a member function
00054 template <typename C>
00055 struct ThreadMemberFunc : ThreadFunc
00056 {
00057     ThreadMemberFunc(void(C::*function)(), C* object) : myFunction(function), myObject(object) {}
00058     virtual void Run() {(myObject->*myFunction)();}
00059     void(C::*myFunction)();
00060     C* myObject;
00061 };
00062 
00063 } // namespace priv
00064 
00065 
00067 template <typename F>
00068 Thread::Thread(F functor) :
00069 myImpl    (NULL),
00070 myFunction(new priv::ThreadFunctor<F>(functor))
00071 {
00072 }
00073 
00074 
00076 template <typename F, typename A>
00077 Thread::Thread(F function, A argument) :
00078 myImpl    (NULL),
00079 myFunction(new priv::ThreadFunctorWithArg<F, A>(function, argument))
00080 {
00081 }
00082 
00083 
00085 template <typename C>
00086 Thread::Thread(void(C::*function)(), C* object) :
00087 myImpl    (NULL),
00088 myFunction(new priv::ThreadMemberFunc<C>(function, object))
00089 {
00090 }