ThreadFunc.h

Go to the documentation of this file.

/*
        Copyright 2003 Joseph Alvis

    This file is part of Aswang.

    Aswang is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Aswang is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Aswang.  If not, see <http://www.gnu.org/licenses/>.
*/

#pragma once
#include "window.h"
#include "process.h"

namespace aswang {
        extern "C" {
                typedef void(*entryFunc)(void *);
        };
        template<typename Class,typename Arg=void *>
        class ThreadFunc {
        private:
                struct func_base {
                        func_base(Class *c) : cptr(c),count(0),destroy(false) {
                                refMut = CreateMutex(0,false,0);
                        }
                        virtual ~func_base() {
                                CloseHandle(refMut);
                        }
                        virtual void operator ()() = 0;
                        Class *cptr;
                        volatile unsigned long count;
                        volatile bool destroy;
                        HANDLE refMut;
                        void inc() {
                                WaitForSingleObject(refMut,INFINITE);
                                ++count;
                                ReleaseMutex(refMut);
                        }
                        bool dec() {
                                WaitForSingleObject(refMut,INFINITE);
                                bool d = (!--count)&&destroy;
                                ReleaseMutex(refMut);
                                return d;
                        }
                        bool setDestroy() {
                                WaitForSingleObject(refMut,INFINITE);
                                if(count!=0)
                                        destroy=true;
                                ReleaseMutex(refMut);
                                return destroy;
                        }
                } *myFunc;
                struct func_noarg : public func_base {
                        func_noarg(Class *c,void(Class::*p)()) : func_base(c),pfunc(p) {}
                        void(Class::*pfunc)();
                        void operator()() {(cptr->*pfunc)();}
                };
                struct func_arg : public func_base {
                        func_arg(Class *c,void(Class::*p)(Arg),Arg a) : func_base(c),pfunc(p),arg(a) {}
                        void(Class::*pfunc)(Arg);
                        Arg arg;
                        void operator()() {(cptr->*pfunc)(arg);}
                };
                ThreadFunc(const ThreadFunc &){}
                const ThreadFunc &operator = (const ThreadFunc &) {}
                static void start(void *arg) {
                        ThreadFunc<Class,Arg>::func_base *ptr = reinterpret_cast<ThreadFunc<Class,Arg>::func_base *>(arg);
                        (*ptr)();
                        if(ptr->dec())
                                delete ptr;
                }
        public:
                ThreadFunc(Class *c,void(Class::*p)()) : myFunc(new func_noarg(c,p)) {}
                ThreadFunc(Class *c,void(Class::*p)(Arg),Arg a=0) : myFunc(new func_arg(c,p,a)) {}
                ~ThreadFunc() {
                        if(!myFunc->setDestroy())
                                delete myFunc;
                }
                void operator () () {
                        entryFunc ptr = (entryFunc)&start;
                        myFunc->inc();
                        _beginthread(ptr,0,myFunc);
                }
                void operator () (Arg p) {
                        static_cast<func_arg *>(myFunc)->arg = p;
                        entryFunc ptr = (entryFunc)&start;
                        myFunc->inc();
                        _beginthread(ptr,0,myFunc);
                }
        };
}