---

epList.c

Go to the documentation of this file.

/*
 *    Undetermined         FIFO                  LIFO                 
 *    +-+-+-+-+-+         +-+-+-+-+-+           +-+-+-+-+-+             
 *    | | | | | |     --> | | | | | | -->       | | | | | | <==>        
 *    +-+-+-+-+-+         +-+-+-+-+-+           +-+-+-+-+-+             
 *     4 3 2 1 0           4 3 2 1 0             4 3 2 1 0              
 */

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

#include "epDefs.h"
#include "epUtils.h"
#include "epList.h"


epList_t *epList_create(const epDir_t direction, 
                        int (*elementDeallocatorFunction)(void *elt))
{
  epList_t *list =(epList_t *) malloc(sizeof(epList_t));
  
  _DEBUG2("entering...");
  _DEBUG3("direction              : %s", _DIR_TO_STRING(direction));
  _DEBUG3("eltDeallocFunc assigned: %s", 
          _BOOL_TO_STRING(elementDeallocatorFunction!=NULL));

  _IF_TRUE_RETURN(!_DIR_IS_VALID(direction), 0, NULL); //direction invalide
  _IF_TRUE_RETURN(list == NULL, 0, NULL); //le malloc a échoué
  

  list->direction = direction;
  list->head = NULL;
  list->tail = NULL;
  list->numOfElements = 0;
  
  list->elementDeallocatorFunction = (elementDeallocatorFunction != NULL?
                                      elementDeallocatorFunction:
                                      epUtils_ptrDeallocatorFunction);
  _RETURN(list);
}

int epList_destroy(epList_t *list)
{
  struct epListElt_s *listElt,
                     *nextListElt;

  _DEBUG2("entering...");
  _IF_TRUE_RETURN(list == NULL, 0, -1); // pas de liste passée en argument

  for(listElt = list->head; listElt != NULL; listElt = nextListElt)
    {
      nextListElt = listElt->next;
      /* si la déallocation d'1 élément échoue(i.e. ne retourne pas 0), 
         erreur */
      _IF_TRUE_RETURN(list->elementDeallocatorFunction(listElt->elt), 0, -1);
      free(listElt);
    }
  
  free(list);
  _RETURN(0);
}

int epList_put(epList_t *list, const int indice, const void *elt)
{
  int i;
  struct epListElt_s *listElt,
                     *curListElt;

  _DEBUG2("entering...");

  /* gerer les messages d'erreur LOCAUX(et leur internationalisation) */
  _IF_TRUE_RETURN(list == NULL, 0, -1);
  _IF_TRUE_RETURN(elt == NULL, 0, -1);
  _IF_TRUE_RETURN(indice < 0, 0, -1);
  
  listElt =(struct epListElt_s *) malloc(sizeof(struct epListElt_s));
  _IF_TRUE_RETURN(listElt == NULL, 0, -1);


  /* insertion into an empty list                                      */
  if(list->numOfElements == 0)
    {
      listElt->prev = NULL;
      listElt->next = NULL;
      
      list->head = listElt;
      list->tail = listElt;
    }
  /* _LIFO direction OR indice = 0              => insert at beginning */
  else if(list->direction == _LIFO || 
          (list->direction != _FIFO && indice == 0))
    { 
      listElt->prev = NULL;
      listElt->next = list->head;
      
      list->head->prev = listElt;
      list->head = listElt;
    }
  /* _FIFO direction OR indice >= numOfElements => insert at end      */
  else if(list->direction == _FIFO || indice >= list->numOfElements)
    { 
      listElt->prev = list->tail;
      listElt->next = NULL;
      
      list->tail->next = listElt;
      list->tail = listElt;
    }
  /* middle-of-the-list element                                      */
  else
    {
      for(i = 1, curListElt = list->head; 
          i < indice; 
          i++, curListElt = curListElt->next);
      
      listElt->prev = curListElt;
      listElt->next = curListElt->next;
      
      curListElt->next->prev = listElt;
      curListElt->next = listElt;
    }

  listElt->elt =(void *)elt;
  list->numOfElements++;

  _RETURN(0);
}

void *epList_get(epList_t *list, const int indice, 
                 const boolean_t removeFromList)
{
  int i;
  void *retelt;
  struct epListElt_s *listElt;

  _DEBUG2("entering...");
  _IF_TRUE_RETURN(list == NULL, 0, NULL); // no list
  _IF_TRUE_RETURN(list->numOfElements == 0, 0, NULL); //empty list
  // invalid indice
  _IF_TRUE_RETURN(indice >= list->numOfElements || indice < 0, 0, NULL); 

  if(list->direction == _FIFO || list->direction == _LIFO || indice == 0) 
    {
      listElt = list->head;
    } else {
      for(i = 0, listElt = list->head; 
          i < indice; 
          i++, listElt = listElt->next);
    }
  
  retelt = listElt->elt;
  
  if(removeFromList)
    { 
      _DEBUG3("removing the %dth element from the list", indice);
      if(listElt->prev == NULL)
        { list->head = listElt->next; }
      else
        { listElt->prev->next = listElt->next; }
      
      if(listElt->next == NULL)
        { list->tail = listElt->prev; }
      else
        { listElt->next->prev = listElt->prev; }
      
      free(listElt);
      list->numOfElements--;
    }
  
  _RETURN(retelt);      
}

void *epList_access(epList_t *list, const int indice)
{
  _DEBUG2("entering...");
  /* ici, on n'utilise pas le warper _RETURN, car le code d'erreur est fixé
     par al fonction appelée epList_get()
  */
  return(epList_get(list, indice, _false));
}

void *__epList_search(const epList_t *list, const searchDir_t direction, 
                      int from, int to, const void *criterion, 
                      boolean_t (*comparisonFunction)
                      (const void *element, const void *criterion), 
                      int *indice)
{
  int i;
  void *retelt = NULL;
  struct epListElt_s *listElt;
  
  _DEBUG2("entering...");
  _IF_TRUE_RETURN(list == NULL, 0, NULL);      // no list
  _IF_TRUE_RETURN(criterion == NULL, 0, NULL); //no search criterion

  if(indice)
    { *indice = -1; }
  if(from == -1)
    { from = (direction ==_NORMAL)?0:(list->numOfElements - 1); }
  if(to == -1)
    { to = (direction ==_NORMAL)?(list->numOfElements - 1):0; }

  // parcours avant
  if(direction == _NORMAL)
    {
      for(listElt = list->head, i = 0; i < to && i < from; 
          listElt = listElt->next, i++);

      for(; i <= to; listElt = listElt->next, i++)
        { 
          if(comparisonFunction(listElt->elt, criterion))
            { 
              retelt = listElt->elt;
              if(indice)
                { *indice = i; }

              break;
            }
        }
  // parcours arrière
    } else if(direction == _REVERSE) {
      for(listElt = list->tail, i = list->numOfElements - 1;
          i > to && i > from; 
          listElt = listElt->prev, i--);

      for(; i >= to; listElt = listElt->prev, i--)
        { 
          if(comparisonFunction(listElt->elt, criterion))
            { 
              retelt = listElt->elt;
              if(indice)
                { *indice = i; }

              break;
            }
        }
    }

  return(retelt);
}

void *epList_search(const epList_t *list, const void *criterion, 
                    boolean_t (*comparisonFunction)
                    (const void *element, const void *criterion))
{
  _DEBUG2("entering...");
  return(__epList_search(list, _NORMAL, -1, -1, criterion, 
                         comparisonFunction, NULL));
}


void *epList_rsearch(const epList_t *list, const void *criterion, 
                     boolean_t (*comparisonFunction)
                     (const void *element, const void *criterion))
{
  _DEBUG2("entering...");
  return(__epList_search(list, _REVERSE, -1, -1, criterion, 
                         comparisonFunction, NULL));
}

int epList_size(epList_t *list)
{
  _DEBUG2("entering...");
  _IF_TRUE_RETURN(list == NULL, 0, -1);

  _RETURN(list->numOfElements);
}

boolean_t epList_isEmpty(epList_t *list)
{
  _DEBUG2("entering...");
  _IF_TRUE_RETURN(list == NULL, 0, -1); //??!!?? _error

  _RETURN(list->numOfElements == 0? _true: _false);
}

int epList_setElementPrintFunction(
  epList_t *list,
  char *(*elementPrintFunction)(void *elt))
{
  _DEBUG2("entering...");
  _IF_TRUE_RETURN(list == NULL, 0, -1); // NULL list

  list->elementPrintFunction = elementPrintFunction;
  _RETURN(0);
}

int epList_printIt(epList_t *list, char *title)
{
  int i;

  _DEBUG2("entering...");
  _IF_TRUE_RETURN(list == NULL, 0, -1); // NULL list

  if(title == NULL)
    { fprintf(stdout, "- List ------------------------------\n"); }
  else
    {
      fprintf(stdout, "- List - %s ", title);
      for(i = 0; i < (27 - strlen(title)); fprintf(stdout, "-"), i++);
      fprintf(stdout, "\n");
    }

  fprintf(stdout, "  * Orientation       : %s\n", 
          _DIR_TO_STRING(list->direction));
  fprintf(stdout, "  * number of Elements: %2d\n", list->numOfElements);

  epList_printElements(list);
  fprintf(stdout, "- End List --------------------------\n");
  _RETURN(0);
}

void epList_printElements(epList_t *list)
{
  int i;
  char *eltString,
       *token;
  struct epListElt_s *listElt;

  _DEBUG2("entering...");
  if(list->elementPrintFunction != NULL)
    {
      fprintf(stdout, "\n  - Elements --\n");
      
      for(listElt = list->head, i = 0; listElt != NULL; 
          listElt = listElt->next, i++)
      {
        fprintf(stdout, "  (%2d)\n", i);

        eltString = strdup(list->elementPrintFunction(listElt->elt));
        token = strtok(eltString, "\n");
        
        do {
          fprintf(stdout, "        %s\n", token);  
        } while((token = strtok(NULL, "\n")) != NULL);

        free(eltString);
      }

      fprintf(stdout, "  - End -------\n");
    }  
}

---