vThread.h

Go to the documentation of this file.

/***************************************************************************
                          vThread.h  -  description
                             -------------------
    begin                : September 2004
    copyright            : (C) 2004 by Jan Flasar
    email                : flasar@fi.muni.cz
 ***************************************************************************/


#ifndef VTHREAD_H
#define VTHREAD_H

#include <vrecko/BaseClass.h>

#ifdef WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif

#include <map>
#include <vector>
#include <osg/Timer>


namespace vrecko {

class BaseClass;

class VRECKO_EXPORT vThread {
    public:
        vThread(BaseClass *ent_ptr, float freq);
        vThread(std::vector<BaseClass*> ent_vec, float freq);
        vThread(void (*funcPtr)(void), float freq);
        vThread(void (*funcPtr)(void), unsigned int step, float freq);
        ~vThread();

        void start(void) {run = true;}
        void stop(void) {run = false;}

        bool getDone(void) {return done;}
        bool getRun(void) {return run;}
        float getFrequency(void) {return frequency;}
        osg::Timer_t getLastTick(void) {return last_tick;}
        BaseClass *getEntityPtr(int pos) {return (*entity_vector)[pos];}
        bool addEntity(BaseClass *ent);
        bool removeEntity(BaseClass *ent);
        void syncEntityVector(void);
        std::vector<BaseClass*> *getEntityVec(void) {return entity_vector;}
        void (*getFuncPtr(void))() {return voidFuncPtr;}
        unsigned int getStepCounter(void) {return step_counter;}
        
#ifdef WIN32
        static HANDLE createMutex();
        static void destroyMutex(HANDLE mutex);
        HANDLE getMutex(void) {return hvT_Mutex;}
#else
        static pthread_mutex_t *createMutex();
        static void destroyMutex(pthread_mutex_t *mutex);
        pthread_mutex_t *getMutex(void) {return hvT_Mutex;}
#endif

        void reportError(const std::string &error);
        inline void reportError(char* error) { reportError(std::string(error)); }

        static unsigned long getDelay(osg::Timer_t last_t, float freq);
        inline unsigned long getDelay(void) { return getDelay(last_tick, frequency); }

        static const osg::Timer *getTimerPtr(void) {return timer;} 
        osg::Timer_t last_tick;

    protected:
#ifndef WIN32
        pthread_t th_read;
#else
        DWORD dwThreadId, dwThrdParam;
        HANDLE hThread;
#endif
        static const osg::Timer *timer;
        std::vector<BaseClass*> *entity_vector;
        std::map<BaseClass*, bool> temp_entity_map;
        void (*voidFuncPtr)(void);
        float frequency;
        bool done, run;
        unsigned int step_counter;

#ifdef WIN32
        HANDLE hvT_Mutex;
#else
        pthread_mutex_t *hvT_Mutex;
#endif
};

}

#endif