master
Louis GERMAIN 1 year ago
parent 601cfb3f66
commit 03eff8d454

@ -1,59 +1,94 @@
/**
* @file structure.h
* @brief Header file containing structures and definitions for project management.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* @def TMAXTRAV
* @brief Maximum number of works (travaux) in the project.
*/
#define TMAXTRAV 8
#define TRACE false
typedef struct
{
char *nomE;
char *adresse;
int capital;
int duree;
int prix;
/**
* @enum Booleen
* @brief Boolean type definition.
*/
typedef enum {
false, /**< Boolean value representing false. */
true /**< Boolean value representing true. */
} Booleen;
/**
* @struct Devis
* @brief Structure representing a quote or bid for a work.
*/
typedef struct {
char *nomE; /**< Name of the company. */
char *adresse; /**< Address of the company. */
int capital; /**< Capital of the company. */
int duree; /**< Duration of the work. */
int prix; /**< Price proposed for the work. */
} Devis;
typedef struct maillonDevis
{
Devis dev;
struct maillonDevis *suiv;
/**
* @struct MaillonDevis
* @brief Node structure representing a quote in the list of quotes.
*/
typedef struct maillonDevis {
Devis dev; /**< Information about the quote. */
struct maillonDevis *suiv; /**< Pointer to the next quote in the list. */
} MaillonDevis, *ListeDevis;
typedef struct
{
char travaux[30];
ListeDevis ldevis;
/**
* @struct Offre
* @brief Structure representing a work offer.
*/
typedef struct {
char travaux[30]; /**< Type of work. */
ListeDevis ldevis; /**< List of quotes for the work. */
} Offre;
typedef enum {
false, true
} Booleen;
typedef struct maillonSucc
{
char tache[20];
struct maillonSucc *nxt;
/**
* @struct MaillonSucc
* @brief Node structure representing a successor in the list of successors.
*/
typedef struct maillonSucc {
char tache[20]; /**< Task name. */
struct maillonSucc *nxt; /**< Pointer to the next successor in the list. */
} MaillonSucc, *Liste;
typedef struct
{
char tache[20];
int duree;
int nbPred;
Liste succ;
int dateDebut;
Booleen traite;
/**
* @struct Tache
* @brief Structure representing a task in the project.
*/
typedef struct {
char tache[20]; /**< Task name. */
int duree; /**< Duration of the task. */
int nbPred; /**< Number of predecessors. */
Liste succ; /**< List of successors. */
int dateDebut; /**< Start date of the task. */
Booleen traite; /**< Boolean flag indicating whether the task has been processed. */
} Tache;
typedef struct
{
char travauxPrec[30];
char travauxSucc[30];
/**
* @struct Precedence
* @brief Structure representing a precedence relationship between two works.
*/
typedef struct {
char travauxPrec[30]; /**< Type of preceding work. */
char travauxSucc[30]; /**< Type of succeeding work. */
} Precedence;
/**
* @struct ListeAttente
* @brief Structure representing a queue for tasks waiting to be processed.
*/
typedef struct fileAtt {
Tache *tab[TMAXTRAV];
int debut;
int fin;
} ListeAttente;
Tache *tab[TMAXTRAV]; /**< Array to store tasks. */
int debut; /**< Front of the queue. */
int fin; /**< Rear of the queue. */
} ListeAttente;

@ -1,8 +1,14 @@
#include "../includes/main.h"
/**
* @file charge.c
* @brief Contient les fonctions liées à la gestion des charges, offres, devis, précédences, et tâches.
*/
// l'initialisation est temporaire, je ne savais pas comment tu voulais la faire
#include "../includes/main.h"
// initialisation des travaux
/**
* @brief Initialise le tableau des travaux.
* @return Un tableau d'offres initialisées.
*/
Offre **initTabTravaux(void)
{
trace("initTabTravaux");
@ -26,11 +32,13 @@ Offre **initTabTravaux(void)
tabTravaux[7] = newOffre("Structure");
return tabTravaux;
}
/*---------------devis---------------*/
}
// Chargement d'une chaine de caracteres depuis un fichier
/**
* @brief Charge une chaîne de caractères depuis un fichier.
* @param file Pointeur vers le fichier.
* @return La chaîne de caractères lue depuis le fichier.
*/
char *readFromFile(FILE *file)
{
trace("readFromFile");
@ -65,7 +73,11 @@ char *readFromFile(FILE *file)
return (str);
}
// Chargement d'un devis depuis un fichier
/**
* @brief Charge un devis depuis un fichier.
* @param devisFile Pointeur vers le fichier de devis.
* @param tabTravaux Tableau des offres.
*/
void loadDevis(FILE *devisFile, Offre **tabTravaux)
{
trace("loadDevis");
@ -83,7 +95,10 @@ void loadDevis(FILE *devisFile, Offre **tabTravaux)
tabTravaux[index]->ldevis = insert(tabTravaux[index]->ldevis, d);
}
// Chagement des offres depuis le fichier devis.txt
/**
* @brief Charge les offres depuis le fichier devis.txt.
* @return Le tableau des offres chargées.
*/
Offre **loadOffre(void)
{
trace("loadOffre");
@ -106,9 +121,12 @@ Offre **loadOffre(void)
return (tabTravaux);
}
/*--------------precedences--------------*/
// Chargement des précédences depuis un fichier
/**
* @brief Charge les précédences depuis un fichier.
* @param tmax Pointeur vers le nombre maximum de précédences.
* @param tlog Pointeur vers le nombre actuel de précédences.
* @return Un tableau de précédences.
*/
Precedence *loadPrec(int *tmax, int *tlog)
{
trace("loadPrec");
@ -159,7 +177,11 @@ Precedence *loadPrec(int *tmax, int *tlog)
return tabP;
}
// Chargement des tâches depuis un fichier pour chaque offre
/**
* @brief Charge les tâches depuis un fichier pour chaque offre.
* @param tabTravaux Tableau des offres.
* @return Le tableau des tâches chargées.
*/
Tache **loadTaches(Offre *tabTravaux[])
{
trace("loadTaches");
@ -196,4 +218,4 @@ Tache **loadTaches(Offre *tabTravaux[])
tabTache[i] = t;
}
return tabTache;
}
}

@ -1,34 +1,55 @@
/**
* @file main.c
* @brief Fichier principal du programme, contenant la fonction main et la fonction de traçage.
*/
#include "../includes/main.h"
int main()
{
/**
* @brief Fonction principale du programme.
* @return 0 en cas de succès.
*/
int main() {
// Initialisation des variables
Precedence *tabP;
Offre **tabTravaux;
Tache **tabTaches;
int p_tmax;
int p_tlog;
// Chargement des offres
tabTravaux = loadOffre();
// Traitement minimal des travaux
minTravaux(tabTravaux);
// Chargement des précédences
tabP = loadPrec(&p_tmax, &p_tlog);
// Affichage des précédences
displayPrecedences(tabP, p_tlog);
// Chargement des tâches
tabTaches = loadTaches(tabTravaux);
// Traitement des tâches
traiterTaches(tabTaches);
// Tri fusion des tâches
triFusion(tabTaches, TMAXTRAV);
// Affichage des tâches triées
afficherTachesTriees(tabTaches, TMAXTRAV);
return 0;
}
void trace(char str[])
{
/**
* @brief Affiche une trace si la constante TRACE est définie.
* @param str Chaîne de caractères à afficher en tant que trace.
*/
void trace(char str[]) {
// Vérification de la constante TRACE
if(TRACE)
printf("\n*-*-* %s *-*-*\n", str);
}
}

@ -1,30 +1,46 @@
/**
* @file part4.c
* @brief Fichier contenant la fonction de traitement des tâches.
*/
#include "../includes/main.h"
void traiterTaches(Tache *tabTache[])
{
/**
* @brief Traite les tâches en utilisant la méthode du graphe topologique.
* @param tabTache Tableau des tâches à traiter.
*/
void traiterTaches(Tache *tabTache[]) {
// Initialisation de la file d'attente
ListeAttente file;
Liste succCourant;
file.debut = 0;
file.fin = 0;
// Enfiler les tâches sans prédécesseurs
for (int i = 0; i < TMAXTRAV; i++)
if (tabTache[i]->nbPred == 0)
enfiler(&file, tabTache[i]);
// Etape courante (utilisation dune boucle)
// Traitement des tâches
while (!estVide(&file))
{
// Récupération de la tâche actuelle
Tache *tacheActuelle = defiler(&file);
succCourant = tacheActuelle->succ;
// Traitement des successeurs
while (succCourant)
{
// Recherche du successeur dans le tableau des tâches
Tache *successeur = trouverTache(tabTache, TMAXTRAV, succCourant->tache);
// Mise à jour de la date de début du successeur et du nombre de prédécesseurs
if (successeur != NULL)
{
successeur->dateDebut = max(successeur->dateDebut, tacheActuelle->dateDebut + tacheActuelle->duree);
successeur->nbPred--;
// Enfiler le successeur si le nombre de prédécesseurs atteint zéro
if (successeur->nbPred == 0)
enfiler(&file, successeur);
}
@ -33,4 +49,3 @@ void traiterTaches(Tache *tabTache[])
}
}
}

@ -1,9 +1,16 @@
#include "../includes/main.h"
/**
* @file sort.c
* @brief Fichier contenant des fonctions de recherche et de tri.
*/
/*-------------recherches-------------*/
#include "../includes/main.h"
// Recherche d'une offre dans le tableau de travaux
// Retourne l'indice de l'offre dans le tableau si elle est trouvée, sinon retourne -1
/**
* @brief Recherche une offre dans le tableau de travaux.
* @param travauxName Nom du travail à rechercher.
* @param tabTravaux Tableau des offres.
* @return L'indice de l'offre dans le tableau si trouvée, sinon -1.
*/
int rechTravaux(char *travauxName, Offre **tabTravaux)
{
trace("rechTravaux");
@ -23,10 +30,11 @@ int rechTravaux(char *travauxName, Offre **tabTravaux)
return -1;
}
// la fonction min ne fonctionne pas
// Recherche et garde la meilleure offre par travaux dans le tableau
// Affiche chaque offre gardee avec le devis ayant le prix le plus bas
/**
* @brief Recherche et garde la meilleure offre par travaux dans le tableau.
* Affiche chaque offre gardée avec le devis ayant le prix le plus bas.
* @param tabTravaux Tableau des offres.
*/
void minTravaux(Offre *tabTravaux[])
{
trace("minTravaux");
@ -66,14 +74,11 @@ void minTravaux(Offre *tabTravaux[])
}
}
/*---------------tri------------------*/
//on la met dans struct.c ?
// Libère la mémoire d'une liste de devis
void freeListeDevis(ListeDevis *ldevis)
/**
* @brief Libère la mémoire d'une liste de devis.
* @param ldevis Liste de devis à libérer.
*/
void freeListeDevis(ListeDevis *ldevis)
{
trace("freeListeDevis");
ListeDevis current = *ldevis;
@ -88,43 +93,15 @@ void freeListeDevis(ListeDevis *ldevis)
*ldevis = NULL;
}
// Boucle principale de fusion de listes de devis
void fusionDevisElements(ListeDevis *R, int *tlogR, ListeDevis *S, int *tlogS, ListeDevis *mergedList, ListeDevis *last, int *k)
{
trace("fusionDevisElements");
ListeDevis *current;
while (*tlogR > 0 && *tlogS > 0)
{
if (strcmp((*R)->dev.nomE, (*S)->dev.nomE) < 0)
{
current = R;
(*tlogR)--;
}
else
{
current = S;
(*tlogS)--;
}
if (!(*mergedList))
{
*mergedList = (ListeDevis)malloc(sizeof(MaillonDevis));
*last = *mergedList;
}
else
{
(*last)->suiv = (ListeDevis)malloc(sizeof(MaillonDevis));
*last = (*last)->suiv;
}
(*last)->dev = (*current)->dev;
*current = (*current)->suiv;
(*last)->suiv = NULL;
(*k)++;
}
}
// Gère les éléments restants après les itérations principales de fusion
void gestionElementsRestants(ListeDevis *mergedList, ListeDevis *last, ListeDevis *source, int *tlogSource, int *k) //UTILE ???
/**
* @brief Gère les éléments restants après les itérations principales de fusion.
* @param mergedList Liste fusionnée.
* @param last Dernier élément de la liste fusionnée.
* @param source Liste source.
* @param tlogSource Taille logique de la liste source.
* @param k Compteur d'éléments.
*/
void gestionElementsRestants(ListeDevis *mergedList, ListeDevis *last, ListeDevis *source, int *tlogSource, int *k)
{
trace("gestionElementsRestants");
while (*tlogSource > 0)
@ -144,8 +121,15 @@ void gestionElementsRestants(ListeDevis *mergedList, ListeDevis *last, ListeDevi
}
}
// Fusionne deux listes de devis triées en une seule liste triée
void fusionMaillonDevis(ListeDevis R, int tlogR, ListeDevis S, int tlogS, ListeDevis *T)
/**
* @brief Fusionne deux listes de devis triées en une seule liste triée.
* @param R Première liste de devis.
* @param tlogR Taille logique de la première liste de devis.
* @param S Seconde liste de devis.
* @param tlogS Taille logique de la seconde liste de devis.
* @param T Liste fusionnée.
*/
void fusionMaillonDevis(ListeDevis R, int tlogR, ListeDevis S, int tlogS, ListeDevis *T)
{
trace("fusionMaillonDevis");
ListeDevis last;
@ -162,8 +146,56 @@ void fusionMaillonDevis(ListeDevis R, int tlogR, ListeDevis S, int tlogS, ListeD
*T = mergedList;
}
// Tri fusion sur une liste de devis
void triFusionListeDevis(ListeDevis *ldevis, int tlog)
/**
* @brief Boucle principale de fusion de listes de devis.
* @param R Première liste de devis.
* @param tlogR Taille logique de la première liste de devis.
* @param S Seconde liste de devis.
* @param tlogS Taille logique de la seconde liste de devis.
* @param mergedList Liste fusionnée.
* @param last Dernier élément de la liste fusionnée.
* @param k Compteur d'éléments.
*/
void fusionDevisElements(ListeDevis *R, int *tlogR, ListeDevis *S, int *tlogS, ListeDevis *mergedList, ListeDevis *last, int *k)
{
trace("fusionDevisElements");
ListeDevis *current;
while (*tlogR > 0 && *tlogS > 0)
{
if (strcmp((*R)->dev.nomE, (*S)->dev.nomE) < 0)
{
current = R;
(*tlogR)--;
}
else
{
current = S;
(*tlogS)--;
}
if (!(*mergedList))
{
*mergedList = (ListeDevis)malloc(sizeof(MaillonDevis));
*last = *mergedList;
}
else
{
(*last)->suiv = (ListeDevis)malloc(sizeof(MaillonDevis));
*last = (*last)->suiv;
}
(*last)->dev = (*current)->dev;
*current = (*current)->suiv;
(*last)->suiv = NULL;
(*k)++;
}
}
/**
* @brief Trie une liste de devis en utilisant l'algorithme de tri fusion.
* @param ldevis Liste de devis à trier.
* @param tlog Taille logique de la liste de devis.
*/
void triFusionListeDevis(ListeDevis *ldevis, int tlog)
{
trace("triFusionListeDevis");
ListeDevis p;
@ -188,7 +220,14 @@ void triFusionListeDevis(ListeDevis *ldevis, int tlog)
*ldevis = mergedList;
}
/**
* @brief Fusionne deux tableaux de tâches triés en un tableau trié.
* @param R Premier tableau de tâches.
* @param tR Taille du premier tableau de tâches.
* @param S Second tableau de tâches.
* @param tS Taille du second tableau de tâches.
* @param T Tableau fusionné.
*/
void fusion(Tache *R[], int tR, Tache *S[], int tS, Tache *T[])
{
int i, j, k;
@ -226,6 +265,13 @@ void fusion(Tache *R[], int tR, Tache *S[], int tS, Tache *T[])
}
}
/**
* @brief Copie les éléments d'un tableau dans un autre.
* @param T Tableau source.
* @param i Indice de début de copie.
* @param j Indice de fin de copie.
* @param R Tableau de destination.
*/
void copy(Tache *T[], int i, int j, Tache *R[])
{
int k;
@ -239,6 +285,11 @@ void copy(Tache *T[], int i, int j, Tache *R[])
}
}
/**
* @brief Trie un tableau de tâches en utilisant l'algorithme de tri fusion.
* @param T Tableau de tâches à trier.
* @param tlog Taille logique du tableau de tâches.
*/
void triFusion(Tache *T[], int tlog)
{
if (tlog <= 1)
@ -259,4 +310,4 @@ void triFusion(Tache *T[], int tlog)
free(R);
free(S);
}
}

@ -1,15 +1,25 @@
#include "../includes/main.h"
/**
* @file structure.c
* @brief Fichier contenant des fonctions liées à l'initialisation, la manipulation et l'affichage des structures de données.
*/
/*----------initialisations ----------*/
#include "../includes/main.h"
// Initialise une liste de devis
/**
* @brief Initialise une nouvelle liste de devis.
* @return Liste de devis initialisée.
*/
ListeDevis newListeDevis(void)
{
trace("newListeDevis");
return NULL;
}
// Initialise une nouvelle offre
/**
* @brief Initialise une nouvelle offre.
* @param travauxName Nom du travail associé à l'offre.
* @return Offre initialisée.
*/
Offre *newOffre(char *travauxName)
{
trace("newOffre");
@ -20,14 +30,20 @@ Offre *newOffre(char *travauxName)
return o;
}
// Initialise une liste (pour les successeurs)
/**
* @brief Initialise une nouvelle liste pour les successeurs.
* @return Liste initialisée.
*/
Liste newListe(void)
{
trace("newListe");
return NULL;
}
//file
/**
* @brief Initialise une file d'attente.
* @return File d'attente initialisée.
*/
ListeAttente* initialiserFileAttente(void)
{
ListeAttente *file;
@ -45,32 +61,45 @@ ListeAttente* initialiserFileAttente(void)
return (file);
}
/*------------verifications------------*/
// Verifie l'integrite d'une liste de devis
/**
* @brief Vérifie si une liste de devis est vide.
* @param l Liste de devis à vérifier.
* @return True si la liste est vide, False sinon.
*/
Booleen emptyListe(ListeDevis l)
{
trace("emptyListe");
return l==NULL;
}
// Vérifie l'intégrité de l'offre
/**
* @brief Vérifie si une offre est vide (sans devis associé).
* @param o Offre à vérifier.
* @return True si l'offre est vide, False sinon.
*/
Booleen emptyOffre(Offre *o)
{
trace("emptyOffre");
return emptyListe(o->ldevis);
}
// file
/**
* @brief Vérifie si une file d'attente est vide.
* @param file File d'attente à vérifier.
* @return True si la file est vide, False sinon.
*/
Booleen estVide(ListeAttente *file)
{
return (file->debut == file->fin);
}
/*-------------insertions---------------*/
// Insere un devis en tete de la liste des devis
/**
* @brief Insère un devis en tête de la liste des devis.
* @param l Liste de devis.
* @param d Devis à insérer.
* @return Liste de devis mise à jour.
*/
ListeDevis insert(ListeDevis l, Devis d)
{
trace("insert");
@ -88,7 +117,12 @@ ListeDevis insert(ListeDevis l, Devis d)
return md;
}
// Insere en queue de liste (les successeurs)
/**
* @brief Insère en queue de liste (pour les successeurs).
* @param l Liste de successeurs.
* @param travaux Nom du travail associé au successeur.
* @return Liste de successeurs mise à jour.
*/
Liste insertSucc(Liste l, char travaux[])
{
trace("insertSucc");
@ -108,8 +142,11 @@ Liste insertSucc(Liste l, char travaux[])
return l;
}
//file
/**
* @brief Ajoute une tâche à la file d'attente.
* @param file File d'attente.
* @param tache Tâche à ajouter.
*/
void enfiler(ListeAttente *file, Tache *tache)
{
if ((file->fin + 1) % TMAXTRAV == file->debut)
@ -122,10 +159,11 @@ void enfiler(ListeAttente *file, Tache *tache)
file->fin = (file->fin + 1) % TMAXTRAV;
}
/*------------suppressions-------------*/
// Supprime le premier maillon de la liste de devis
/**
* @brief Supprime le premier maillon de la liste de devis.
* @param l Liste de devis.
* @return Liste de devis mise à jour.
*/
ListeDevis del(ListeDevis l)
{
trace("del");
@ -152,7 +190,11 @@ ListeDevis del(ListeDevis l)
return (l);
}
//file
/**
* @brief Défile une tâche de la file d'attente.
* @param file File d'attente.
* @return Tâche défilée.
*/
Tache* defiler(ListeAttente *file)
{
Tache *tache;
@ -165,9 +207,12 @@ Tache* defiler(ListeAttente *file)
return (tache);
}
/*---------------calculs----------------*/
// Calcule la longueur de la liste de devis
/**
* @brief Calcule la longueur d'une liste de devis.
* @param l Liste de devis.
* @return Longueur de la liste.
*/
int lenListeDevis(ListeDevis l)
{
trace("lenListeDevis");
@ -180,7 +225,12 @@ int lenListeDevis(ListeDevis l)
return (len);
}
int lenMaxNomEntreprise(ListeDevis ldevis)
/**
* @brief Calcule la longueur maximale du nom d'entreprise dans une liste de devis.
* @param ldevis Liste de devis.
* @return Longueur maximale du nom d'entreprise.
*/
int lenMaxNomEntreprise(ListeDevis ldevis)
{
trace("lenMaxNomEntreprise");
int maxLen;
@ -197,7 +247,13 @@ int lenMaxNomEntreprise(ListeDevis ldevis)
return (maxLen);
}
// Calcule le nombre de precedences pour un travail donne
/**
* @brief Calcule le nombre de précédences pour un travail donné.
* @param travaux Nom du travail.
* @param prec Tableau de précédences.
* @param tlog Taille logique du tableau de précédences.
* @return Nombre de précédences.
*/
int nombrePred(char travaux[], Precedence prec[], int tlog)
{
trace("nombrePred");
@ -208,15 +264,27 @@ int nombrePred(char travaux[], Precedence prec[], int tlog)
return nbPred;
}
/**
* @brief Retourne le maximum entre deux entiers.
* @param a Premier entier.
* @param b Deuxième entier.
* @return La valeur maximale entre a et b.
*/
int max(int a, int b)
{
if (a > b)
return (a);
return a;
else
return (b);
return b;
}
int calculerDureeProjet(Tache **tachesTriees, int nbTaches)
/**
* @brief Calcule la durée totale du projet en fonction des tâches triées.
* @param tachesTriees Tableau des tâches triées.
* @param nbTaches Nombre de tâches dans le tableau.
* @return La durée totale du projet.
*/
int calculerDureeProjet(Tache **tachesTriees, int nbTaches);
{
int i;
int dureeProjet;
@ -232,10 +300,14 @@ int calculerDureeProjet(Tache **tachesTriees, int nbTaches)
return (dureeProjet);
}
/*--------------informations------------*/
// Retourne une liste des successeurs pour un travail donne
Liste lstSucc(char travaux[], Precedence prec[], int tlog)
/**
* @brief Retourne une liste des successeurs pour un travail donné.
* @param travaux Nom du travail.
* @param prec Tableau des précédences.
* @param tlog Taille logique du tableau des précédences.
* @return Liste des successeurs pour le travail donné.
*/
Liste lstSucc(char travaux[], Precedence prec[], int tlog);
{
trace("lstSucc");
int i;
@ -248,8 +320,14 @@ Liste lstSucc(char travaux[], Precedence prec[], int tlog)
return succ;
}
// Fonction pour trouver une tâche par son nom
Tache* trouverTache(Tache **tabTache, int nbTaches, char *nom)
/**
* @brief Trouve une tâche par son nom dans un tableau de tâches.
* @param tabTache Tableau de tâches.
* @param nbTaches Nombre de tâches dans le tableau.
* @param nom Nom de la tâche à trouver.
* @return Pointeur vers la tâche trouvée, ou NULL si non trouvée.
*/
Tache* trouverTache(Tache **tabTache, int nbTaches, char *nom)
{
int i;
@ -262,6 +340,12 @@ Tache* trouverTache(Tache **tabTache, int nbTaches, char *nom)
return (NULL);
}
/**
* @brief Liste les tâches restantes à réaliser après une date donnée.
* @param tachesTriees Tableau des tâches triées.
* @param nbTaches Nombre de tâches dans le tableau.
* @param date Date de référence.
*/
void listerTachesRestantes(Tache **tachesTriees, int nbTaches, int date)
{
printf("Taches restantes a realiser :\n");
@ -270,16 +354,21 @@ void listerTachesRestantes(Tache **tachesTriees, int nbTaches, int date)
printf("Tache: %s\n", tachesTriees[i]->tache);
}
/*---------------affichages--------------*/
// Affiche les details d'un devis
/**
* @brief Affiche les détails d'un devis.
* @param d Devis à afficher.
*/
void displayDevis(Devis d)
{
trace("displayDevis");
printf("\t%s\t%s\t%d\t%d\t%d\n", d.nomE, d.adresse, d.capital, d.duree, d.prix);
}
// Affiche les details de l'offre et sa liste de devis
/**
* @brief Affiche les détails d'une offre, y compris sa liste de devis.
* @param o Offre à afficher.
*/
void displayOffre(Offre *o)
{
trace("displayOffre");
@ -288,7 +377,10 @@ void displayOffre(Offre *o)
printf("\n");
}
// Affiche les details de la liste de devis
/**
* @brief Affiche les détails d'une liste de devis.
* @param l Liste de devis à afficher.
*/
void displayListeDevis(ListeDevis l)
{
trace("displayListeDevis");
@ -299,7 +391,10 @@ void displayListeDevis(ListeDevis l)
}
}
// Fonction pour afficher le devis d'une entreprise donnée pour un type de travaux donné
/**
* @brief Affiche le devis d'une entreprise donnée pour un type de travaux donné.
* @param tabTravaux Tableau des offres.
*/
void afficherDevisEntreprise(Offre **tabTravaux)
{
trace("afficherDevisEntreprise");
@ -326,7 +421,7 @@ void afficherDevisEntreprise(Offre **tabTravaux)
fgets(nomEntreprise, maxlen + 1, stdin);
ListeDevis listeDevis = tabTravaux[indiceTravaux]->ldevis;
while (listeDevis)
while (listeDevis != NULL)
{
if (strcmp(listeDevis->dev.nomE, nomEntreprise) == 0)
{
@ -341,7 +436,12 @@ void afficherDevisEntreprise(Offre **tabTravaux)
free(nomEntreprise);
}
void displayPrecedences(Precedence *tabP, int tlog)
/**
* @brief Affiche les précédences entre les travaux.
* @param tabP Tableau des précédences.
* @param tlog Taille logique du tableau des précédences.
*/
void displayPrecedences(Precedence *tabP, int tlog)
{
trace("displayPrecedences");
int i;
@ -351,6 +451,11 @@ void displayPrecedences(Precedence *tabP, int tlog)
printf("\t%s\t\t : \t%s\n", tabP[i].travauxPrec, tabP[i].travauxSucc);
}
/**
* @brief Affiche les tâches triées par ordre d'exécution.
* @param tachesTriees Tableau des tâches triées.
* @param p_tmax Taille du tableau des tâches triées.
*/
void afficherTachesTriees(Tache *tachesTriees[], int p_tmax)
{
int j;

Loading…
Cancel
Save