Traitement-signal-plantes/Code-C/queue.c

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

/**
 * @brief struct queue struct used for queueing string name  
 * 
 * @param charLen lenght of tabChar pointeur
 * @param tabChar char array pointer
 * @param pNextE point next element 
 */
struct queue {
    int charLen;
    char * tabChar;
    Pqueue  pNextE;
};

typedef struct queue *Pqueue;

/**
 * @brief create an empty element of queue
 * 
 * @return Pqueue 
 */
<<<<<<< HEAD
Pqueue queueCreateEmpty(){
=======
Pqueue createE(int lenChar){
>>>>>>> 2e7253c43c8e65a98686582d853147831016103f
    Pqueue new = (Pqueue) malloc(sizeof(struct queue));
    assert(new);
    new->charLen = 0;
    new->tabChar = NULL;
    new->pNextE = NULL;
    return new;
}

                                    /************ SETTER ************/

/**
 * @brief set char size array
 * 
 * @param elem targeted element
 * @param _charLen size of char array
 * @return Pqueue 
 */
Pqueue queueSetCharLen(Pqueue elem, int _charLen){
    assert(elem);
    elem->charLen = _charLen;
}

/**
 * @brief set the char array in the element
 * 
 * @param elem targeted element
 * @param _charLen char array size
 * @param _tabChar pointer to static char array
 * @return Pqueue 
 */
Pqueue queueSetTabChar(Pqueue elem, int _charLen, const char *_tabChar){
    assert(elem);
    assert(_tabChar);
    elem->charLen = _charLen;
    elem->tabChar = (char *) malloc(_charLen * sizeof(char));
    for(int i = 0; i < _charLen; i++){
        new->tabChar[i] = _tabChar[i];
    }
}

                                    /************ GETTER ************/

/**
 * @brief switch to the next element
 * 
 * @param elem current element
 * @return Pqueue next element
 */
Pqueue queueGetNextE(Pqueue elem){
    assert(elem);
    return elem->pNextE;
}

/**
 * @brief get the size char array
 * 
 * @param elem targeted element
 * @return int 
 */
int queueGetCharLen(Pqueue elem){
    assert(elem);
    return elem->charLen;
}

/**
 * @brief get the pointer of char array
 * 
 * @param elem targeted elemnt
 * @return char* 
 */
char * queueGetTabChar(Pqueue elem){
    assert(elem);
    return elem->tabChar;
}

<<<<<<< HEAD
                                    /************       ************/

/**
 * @brief Create Element of queue
 * 
 * @param lenChar size of char array that will be created 
 * @return Pqueue new element created
 */
Pqueue queueCreateE(int lenChar, const char* _tabChar){
    Pqueue new = (Pqueue) malloc(sizeof(struct queue));
    assert(new);
    queueSetTabChar(new, lenChar, _tabChar);
    new->pNextE = NULL;
    return new;
=======
void setCharLen(Pqueue elem , int _charLen){
    assert(elem);
    elem->charLen = _charLen;
}

void setTabChar(Pqueue elem , int _charLen , char *_tabChar){
    assert(elem);
    elem->charLen = _charLen;
    elem->tabChar = (char *) malloc(_charLen * sizeof(char));
    elem->tabChar = _tabChar;
>>>>>>> 2e7253c43c8e65a98686582d853147831016103f
}

void setNextE(Pqueue elem , Pqueue next){
    assert(elem);
    assert(next);
    elem -> pNextE = next;
}

/**
 * @brief remove and free the last element of queue
 * 
 * @param elem current element
 * @return Pqueue current element
 */
Pqueue queueRmLastE(Pqueue elem){
    assert(elem);
    Pqueue tmp = elem, previous = NULL;
    while(elem->pNextE != NULL){
        previous = tmp;
        tmp = queueGetNextE(tmp);
    }
    free(tmp->tabChar);
    free(tmp);
    previous->pNextE = NULL;
    return elem;
}

/**
 * @brief remove and free the first element of queue
 * 
 * @param elem target to remove (the element need to be the first)
 * @return Pqueue the second element after remove first
 */
Pqueue queueRmFrstE(Pqueue elem){
    assert(elem);
    Pqueue tmp = elem->pNextE;
    free(elem->tabChar);
    free(elem);
    return tmp;
}

/**
 * @brief delete the first value and return the next value
 * 
 * @param elem 
 * @return Pqueue 
 */
Pqueue queueNextDelFrst(Pqueue elem){
    assert(elem);
    Pqueue tmp = elem->pNextE;
    queueRmFrstE(elem);
    return tmp;
}

/**
 * @brief add in the end of queue element with string parameter 
 * 
 * @param elem Pqueue will be added at the end of queue
 * @param str the string will be bind at the element
 * @param len the lenght of char array
 * @return Pqueue pointer to the last element
 */
Pqueue queueAddLastQ(Pqueue elem, const char* str, int len){
    assert(elem);
    assert(str);
    Pqueue tmp = elem, previous = NULL;
    while(elem->pNextE != NULL){
        previous = tmp;
        tmp = queueGetNextE(tmp);
    }
<<<<<<< HEAD
    tmp = queueCreateE(len);
    tmp->tabChar = str;
    tmp->charLen = len;
    return tmp;
=======
    tmp -> pNextE = createE(len);
    Pqueue next  = getNextE(tmp);
    next->tabChar = str;
    next->charLen = len;
    return next;
>>>>>>> 2e7253c43c8e65a98686582d853147831016103f
}

/**
 * @brief Print targeted element
 * 
 * @param elem targeted element
 */
void queuePrintE(Pqueue elem){
    Pqueue next = queueGetNextE(elem);
    printf("File Name : %s \n(size of the file name : %d)\n",elem -> tabChar , elem -> charLen );
    if(next != NULL){
        printf("Next File : %s\n", next ->tabChar);
    }
    else{
        printf("No nextFile existing\n");
    }
}