Multitache.h

Aller à la documentation de ce fichier.

/*! \file Multitache.h
    \brief Surcouche pour multitache.

    Redéfinie tout un tas de fonctions système pour les rendre portables unix et windows.

    \author     aerith (www.aerith.fr)
    \version    1.0
    \date       18/03/2007
*/

#ifndef INCLUDE_RSRC_PORTAGE_MULTITACHE
#define INCLUDE_RSRC_PORTAGE_MULTITACHE


#ifdef WIN32
    #include    <windows.h>

    typedef HANDLE                  THREAD;
    typedef HANDLE                  MUTEX;
#ifndef ROUTINE
    typedef LPTHREAD_START_ROUTINE  ROUTINE;
#endif
    typedef LPVOID                  PARAMETRE;

#else
    #include    <pthread.h>

    //! Une tache
    /*! Crée une tache pour le multitache. */
    typedef pthread_t               THREAD;

    //! Une syncronisation
    /*! Crée un verou permétant de syncroniser des operations dans une application multitache. */
    typedef pthread_mutex_t         MUTEX;

#ifndef ROUTINE
    //! Nom de routine
    /*! Pointe sur une fonction. */
    typedef void *(*ROUTINE)(void *);
#endif

    //! Pointeur sur une variable quelquonque
    /*! Pointe sur une variable de n'importe quel type. */
    typedef void *                  PARAMETRE;
#endif


//! Demare un thread
/*! Demare une tache \a Process avec un parametre \a Param.
    \param pThread adresse memoire du thread
    \param Process nom de la routine à threader
    \param Param parametre a passer à la routine
    \return 1 si OK sinon 0
    \sa ThreadStop(), ThreadExit() et ThreadWait()
*/
int     ThreadStart(THREAD *pThread, ROUTINE Process, PARAMETRE Param);

//! Stop un thread
/*! Force la fermeture d'une tache.
    \param pThread adresse memoire du thread
    \sa ThreadStart(), ThreadExit() et ThreadWait()
*/
void    ThreadStop(THREAD *pThread);

//! Sortie d'un thread
/*! Sortie propre d'une tache et renvoie \a iExitCode au systeme.
    \param iExitCode code retourner au systeme
    \sa ThreadStart(), ThreadStop() et ThreadWait()
*/
void    ThreadExit(int iExitCode);

//! Attent un thread
/*! Pause la tache en cour en attente de la fin de la tache donnée.
    \param pThread adresse memoire du thread
    \sa ThreadStart(), ThreadStop() et ThreadExit()
*/
void    ThreadWait(THREAD *pThread);

//! Initialise un mutex
/*! Initialise un verou de syncronisation de tache
    \param pMutex adresse memoire du mutex
    \sa MutexLock(), MutexUnLock() et MutexStop()
*/
void    MutexInit(MUTEX *pMutex);

//! Attent un mutex
/*! Pause la tache en cour en attente du déverouillage du mutex et va le verouillé.
    \param pMutex adresse memoire du mutex
    \sa MutexInit(), MutexUnLock() et MutexStop()
*/
void    MutexLock(MUTEX *pMutex);

//! Libere un mutex
/*! Déverouille le mutex préalablement réservé.
    \param pMutex adresse memoire du mutex
    \sa MutexInit(), MutexLock() et ThreadExit()
*/
void    MutexUnLock(MUTEX *pMutex);

//! Stop un mutex
/*! Déverouille et détrui un mutex.
    \param pMutex adresse memoire du mutex
    \sa MutexInit(), MutexLock() et MutexUnLock()
*/
void    MutexStop(MUTEX *pMutex);

#endif

---