Surcouche.h

Aller à la documentation de ce fichier.

/*! \file Surcouche.h
    \brief Surcouche pour reseau, multitache, console et temp.

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

    \author     aerith (contact@aerith.biz - www.aerith.biz)
    \version    1.0
    \date       30/05/2006
*/

#ifndef INCLUDE_RSRC_PORTAGE
#define INCLUDE_RSRC_PORTAGE


#include    <stdio.h>
#include    <stdlib.h>

//! Exécution de méthode
/*! Exécute la méthode \a methode de la class \a class. */
#define CALL(class, methode)    ((class).*(methode))

#ifdef WIN32
    #include    <windows.h>
    #include    <winbase.h>
    #include    <conio.h>
    #include    <winsock.h>
    #include    <time.h>

    typedef HANDLE                  THREAD;
    typedef HANDLE                  MUTEX;
    typedef LPTHREAD_START_ROUTINE  ROUTINE;
    typedef LPVOID                  PARAMETRE;

    typedef HANDLE                  CONSOLE;
    typedef CHAR_INFO               CHARINFO;

    typedef HINSTANCE               MODULE;

    typedef HANDLE                  DIRECTORY;
#else
    #include    <unistd.h>
    #include    <sys/socket.h>
    #include    <netinet/in.h>
    #include    <netdb.h>
    #include    <sys/types.h>
    #include    <arpa/inet.h>
    #include    <sys/time.h>
    #include    <pthread.h>
    #include    <dlfcn.h>
    #include    <signal.h>
    #include    <dirent.h>
    #include    <sys/stat.h>

    //! Socket
    /*! Redéfinie le type utilisé sous unix pour l'utiliser comme celui de windows. */
    typedef int                     SOCKET;

    //! Information sur socket
    /*! Redéfinie le type utilisé sous unix pour l'utiliser comme celui de windows. */
    typedef struct sockaddr_in      SOCKADDR_IN;

    //! 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;

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

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

    //! Buffer de console
    /*! Crée un buffer d'affichage pour la console permétant des manipulations.
        \bug rechercher l'équivalent unix
    */
    typedef void *                  CONSOLE;

    //! Info sur carractere
    /*! Inforamation sur un carractere de console (couleur, attribut et char).
        \bug rechercher l'équivalent unix
    */
    typedef void *                  CHARINFO;


    //! Un module dynamique
    /*! Crée un module dynamique (dll ou so). */
    typedef void *                  MODULE;

    typedef DIR *                   DIRECTORY;


#endif


//****************************** Multitache ************************************
//! 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);


//******************************* Module ***************************************
//! Charge un module
/*! Charge un module dynamique.
    \param pModule adresse mémoire du module chargé.
    \param pName fichier du module à charger.
    \return 1 si OK sinon 0
    \sa ModuleUnLoad() et ModuleImport()
*/
int     ModuleLoad(MODULE *pModule, char *pName);

//! Decharge un module
/*! Decharge un module dynamique.
    \param pModule pointeur sur le module à decharger.
    \return
    \sa ModuleLoad() et ModuleImport()
*/
int     ModuleUnload(MODULE *pModule);

//! Importe une fonction
/*! Importe une fonction depuis un module dynamique.
    \param Module pointeur sur module.
    \param pFonction adresse mémoir de la fonction importé.
    \param pName nom de la fonction à importer.
    \return 1 si OK sinon 0
    \sa ModuleLoad() et ModuleUnLoad()
*/
int     ModuleImport(MODULE Module, ROUTINE *pFonction, char *pName);


//******************************* Reseau ***************************************
//! Configure le reseau
/*! Configure l'os pour l'utilisation de socket.
    \return 1 si OK sinon 0
    \sa SocketUnLoad() et SocketClose()
*/
int     SocketLoad(void);

//! Libere le reseau
/*! Relache la gestion du reseau.
    \sa SocketLoad() et SocketClose()
*/
void    SocketUnLoad(void);

//! Ferme un socket
/*! Relache un socket proprement.
    \param Sock le socket à fermé
    \sa SocketLoad() et SocketUnLoad()
*/
void    SocketClose(SOCKET Sock);


//********************************** Temp **************************************
//! Attend un certain delai
/*! Fait rentrée la tache en cour d'éxécution en attente pendant \a Delai ms.
    \param Delai nombre de milliseconde a attendre
*/
void    TempWait(unsigned int Delai);

//! Marque une pause
/*! Pause la tache en attente de la frappe d'une touche.
    \bug rechercher l'équivalent unix
*/
void    TempPause();


//******************************** Console *************************************
//! Efface la console
/*! Vide le buffer \a stdout et efface la console.
*/
void    ConsoleClear();

#define     COLOR_F_NOIR    0x0000      /*!< police noir        */
#define     COLOR_F_BLEU    0x0001      /*!< police bleu foncé  */
#define     COLOR_F_VERT    0x0002      /*!< police vert foncé  */
#define     COLOR_F_BGRIS   0x0003      /*!< police bleu-gris   */
#define     COLOR_F_MARRON  0x0004      /*!< police marron      */
#define     COLOR_F_POUPRE  0x0005      /*!< police pourpre     */
#define     COLOR_F_KAKI    0x0006      /*!< police kaki        */
#define     COLOR_F_GCLAIR  0x0007      /*!< police gris clair  */
#define     COLOR_F_GRIS    0x0008      /*!< police gris        */
#define     COLOR_F_BCLAIR  0x0009      /*!< police bleu clair  */
#define     COLOR_F_VCLAIR  0x000A      /*!< police vert clair  */
#define     COLOR_F_CYAN    0x000B      /*!< police cyan        */
#define     COLOR_F_ROUGE   0x000C      /*!< police rouge       */
#define     COLOR_F_ROSE    0x000D      /*!< police rose        */
#define     COLOR_F_JAUNE   0x000E      /*!< police jaune       */
#define     COLOR_F_BLANC   0x000F      /*!< police blanc       */
#define     COLOR_B_NOIR    0x0000      /*!< fond noir          */
#define     COLOR_B_BLEU    0x0010      /*!< fond bleu foncé    */
#define     COLOR_B_VERT    0x0020      /*!< fond vert foncé    */
#define     COLOR_B_BGRIS   0x0030      /*!< fond bleu-gris     */
#define     COLOR_B_MARRON  0x0040      /*!< fond marron        */
#define     COLOR_B_POUPRE  0x0050      /*!< fond pourpre       */
#define     COLOR_B_KAKI    0x0060      /*!< fond kaki          */
#define     COLOR_B_GCLAIR  0x0070      /*!< fond gris clair    */
#define     COLOR_B_GRIS    0x0080      /*!< fond gris          */
#define     COLOR_B_BCLAIR  0x0090      /*!< fond bleu clair    */
#define     COLOR_B_VCLAIR  0x00A0      /*!< fond vert clair    */
#define     COLOR_B_CYAN    0x00B0      /*!< fond cyan          */
#define     COLOR_B_ROUGE   0x00C0      /*!< fond rouge         */
#define     COLOR_B_ROSE    0x00D0      /*!< fond rose          */
#define     COLOR_B_JAUNE   0x00E0      /*!< fond jaune         */
#define     COLOR_B_BLANC   0x00F0      /*!< fond blanc         */

//! Change la couleur de la console
/*! Définie la couleur de police et de fond de la console.
    \bug rechercher l'équivalent unix
    \param iColor couleur de la zone (ex : COLOR_B_BLANC|COLOR_F_BLEU)
    \sa COLOR_F_NOIR, COLOR_F_BLEU, COLOR_F_VERT, COLOR_F_BGRIS, COLOR_F_MARRON, COLOR_F_POUPRE,
        COLOR_F_KAKI, COLOR_F_GCLAIR, COLOR_F_GRIS, COLOR_F_BCLAIR, COLOR_F_VCLAIR, COLOR_F_CYAN,
        COLOR_F_ROUGE, COLOR_F_ROSE, COLOR_F_JAUNE, COLOR_F_BLANC, COLOR_B_NOIR, COLOR_B_BLEU,
        COLOR_B_VERT, COLOR_B_BGRIS, COLOR_B_MARRON, COLOR_B_POUPRE, COLOR_B_KAKI, COLOR_B_GCLAIR,
        COLOR_B_GRIS, COLOR_B_BCLAIR, COLOR_B_VCLAIR, COLOR_B_CYAN, COLOR_B_ROUGE, COLOR_B_ROSE,
        COLOR_B_JAUNE, COLOR_B_BLANC.
*/
void    ConsoleSetColor(unsigned int iColor);

//! Change la couleur de carracteres
/*! Définie la couleur de police et de fond d'un certain nombre de carracteres.
    \bug rechercher l'équivalent unix
    \param pConsole pointeur sur le buffer de console
    \param iPosX colone du premier carractere
    \param iPosY ligne du premier carractere
    \param iColor couleur de la zone (ex : COLOR_B_BLANC|COLOR_F_BLEU)
    \param iLength nombre de carracteres à coloré
    \return 1 si OK sinon 0
    \sa COLOR_F_NOIR, COLOR_F_BLEU, COLOR_F_VERT, COLOR_F_BGRIS, COLOR_F_MARRON, COLOR_F_POUPRE,
        COLOR_F_KAKI, COLOR_F_GCLAIR, COLOR_F_GRIS, COLOR_F_BCLAIR, COLOR_F_VCLAIR, COLOR_F_CYAN,
        COLOR_F_ROUGE, COLOR_F_ROSE, COLOR_F_JAUNE, COLOR_F_BLANC, COLOR_B_NOIR, COLOR_B_BLEU,
        COLOR_B_VERT, COLOR_B_BGRIS, COLOR_B_MARRON, COLOR_B_POUPRE, COLOR_B_KAKI, COLOR_B_GCLAIR,
        COLOR_B_GRIS, COLOR_B_BCLAIR, COLOR_B_VCLAIR, COLOR_B_CYAN, COLOR_B_ROUGE, COLOR_B_ROSE,
        COLOR_B_JAUNE, COLOR_B_BLANC.
*/
int     ConsoleCharColor(CONSOLE *pConsole, unsigned int iPosX, unsigned int iPosY, unsigned int iColor, unsigned int iLength);

//! Ecrit dans le buffer des carracteres
/*! Ecrit des carracteres a une position donnée dans la console
    \bug rechercher l'équivalent unix
    \param pConsole pointeur sur le buffer de console
    \param iPosX colone du premier carractere
    \param iPosY ligne du premier carractere
    \param pData carracteres à ecrire
    \param iLength nombre de carracteres à ecrire, si NULL la taille de \a pData sera prise
    \return 1 si OK sinon 0
    \sa ConsoleCharColor(), ConsoleCharRead().
*/
int     ConsoleCharWrite(CONSOLE *pConsole, unsigned int iPosX, unsigned int iPosY, char *pData, unsigned int iLength);

//! Lit dans le buffer des carracteres
/*! Lit des carracteres a une position donnée dans la console.
    \bug rechercher l'équivalent unix
    \param pConsole pointeur sur le buffer de console
    \param iPosX colone du premier carractere
    \param iPosY ligne du premier carractere
    \param pData carracteres à ecrire
    \param iLength nombre de carracteres à lire, si NULL la taille de \a pData sera prise
    \return 1 si OK sinon 0
    \sa ConsoleCharColor(), ConsoleCharWrite().
*/
int     ConsoleCharRead(CONSOLE *pConsole, unsigned int iPosX, unsigned int iPosY, char *pData, unsigned int iLength);

//! Ecrit dans le buffer une zone
/*! Ecrit dans une zone à une position donnée dans la console
    \bug rechercher l'équivalent unix
    \param pConsole pointeur sur le buffer de console
    \param iPosX colone du premier carractere
    \param iPosY ligne du premier carractere
    \param iLength largeur de la zone
    \param iHeight hauteur de la zone
    \param pData information sur les carracteres à ecrire
    \return 1 si OK sinon 0
    \sa ConsoleCharColor(), ConsoleCharRead() et ConsoleZoneRead().
*/
int     ConsoleZoneWrite(CONSOLE *pConsole, unsigned int iPosX, unsigned int iPosY, unsigned int iLength, unsigned int iHeight, CHARINFO *pData);

//! Lit dans le buffer une zone
/*! Lit dans une zone à une position donnée dans la console
    \bug rechercher l'équivalent unix
    \param pConsole pointeur sur le buffer de console
    \param iPosX colone du premier carractere
    \param iPosY ligne du premier carractere
    \param iLength largeur de la zone
    \param iHeight hauteur de la zone
    \param pData information sur les carracteres à lire
    \return 1 si OK sinon 0
    \sa ConsoleCharColor(), ConsoleCharRead() et ConsoleZoneWrite().
*/
int     ConsoleZoneRead(CONSOLE *pConsole, unsigned int iPosX, unsigned int iPosY, unsigned int iLength, unsigned int iHeight, CHARINFO *pData);


//******************************** Touche **************************************
//! Retourne une touche
/*! Retourne la plus vielle touche du buffer \a stdin.
    \return code ascii de la touche
    \sa KeyGet2(), KeyWait() et KeyPressed()
*/
int     KeyGet();

//! Retourne une touche sans valider
/*! Retourne la plus vielle touche du buffer \a stdin sans devoir presser 'entrée'.
    \bug rechercher l'équivalent unix
    \return code ascii de la touche
    \sa KeyGet(), KeyWait() et KeyPressed()
*/
int     KeyGet2();

//! Attend la frappe d'une touche et la retourne
/*! Pause la tache en attente de la frappe d'une touche et retourne son code.
    \bug rechercher l'équivalent unix
    \return 0 code ascii de la touche
    \sa KeyGet(), KeyGet2() et KeyPressed()
*/
int     KeyWait();

//! Permet de savoir si une touche a été presser
/*! Permet de savoir si une touche a été presser.
    \bug rechercher l'équivalent unix
    \return 0 si non presser sinon > 1
    \sa KeyGet(), KeyGet2() et KeyWait()
*/
int     KeyPressed();


//******************************** Fichier *************************************
//! Supprime un fichier
/*! Supprime un fichier via l'os.
    \bug rechercher l'équivalent unix
    \param pName nom du fichier (relatif ou absolu)
    \return 0 si reussi, sinon 1.
    \sa FileRename()
*/
int     FileDelete(char *pName);

//! Renome un fichier ou repertoire
/*! Renome un fichier ou repertoire via l'os, permet aussi de le déplacé.
    \param pName nom du fichier ou repertoire (relatif ou absolu)
    \param pNewName nouveau nom du fichier ou repertoire
    \return 0 si reussi, sinon 1.
    \sa FileDelete()
*/
int     FileRename(char *pName, char *pNewName);

//******************************* Reperoire ************************************
//! Ouvre un dossier
/*! Ouvre un dossier pour l'explorer et recupère la première donnée.
    \param pDirName nom du dossier
    \param pFirstData nom de la première donnée du repertoire
    \param pIsFile seras mi à 1 si \a pFirstData est un fichier, sinon 0
    \return 0 si reussi, sinon 1.
    \sa DirClose(), DirGetNext(), DirCreate() et DirDelete()
*/
DIRECTORY       DirOpen(char *pDirName, char *pFirstData, int *pIsFile);

//! Ferme un dossier
/*! Ferme un dossier explorer.
    \param pDir pointeur sur dossier
    \return 0 si reussi, sinon 1.
    \sa DirOpen(), DirGetNext(), DirCreate() et DirDelete()
*/
int     DirClose(DIRECTORY *pDir);

//! Récupère une donnée d'un dossier
/*! Récupère la donnée suivante d'un dossier.
    \param pDir pointeur sur dossier
    \param pNextData nom de la donnée suivante du repertoire
    \param pIsFile seras mi à 1 si \a pNextData est un fichier, sinon 0
    \return 0 si reussi, sinon 1.
    \sa DirOpen(), DirClose(), DirCreate() et DirDelete()
*/
int     DirGetNext(DIRECTORY *pDir, char *pNextData, int *pIsFile);

//! Crée un repertoire
/*! Crée un repertoire via l'os.
    \param pName nom du repertoire (relatif ou absolu)
    \return 0 si reussi, sinon 1.
    \sa DirOpen(), DirClose(), DirGetNext() et DirDelete()
*/
int     DirCreate(char *pName);

//! Supprime un repertoire
/*! Supprime un repertoire vide via l'os.
    \param pName nom du repertoire (relatif ou absolu)
    \return 0 si reussi, sinon 1.
    \sa DirOpen(), DirClose(), DirGetNext() et DirCreate()
*/
int     DirDelete(char *pName);

#endif

---