Référence du fichier linked_list.c

Fonctions de gestion de listes chainees. Plus de détails...

#include "linked_list.h"
#include <stdlib.h>
#include <assert.h>

Graphe des dépendances par inclusion de linked_list.c:

Aller au code source de ce fichier.

Fonctions
linked_list_t *	llNew (void)
void	llPushBack (linked_list_t *ll, void *data)
void	llPush (linked_list_t *ll, void *data)
void *	llPop (linked_list_t *ll)
int	llEmpty (linked_list_t *ll)
pair_t	llInsert (linked_list_t *ll, void *data, int(*compar)(const void *newData, const void *nodeData))
void	llInsertAt (llnode_t **here, void *data)
pair_t	llFind (linked_list_t *ll, const void *data, int(*compar)(const void *newData, const void *nodeData))
void	llDelete (linked_list_t *ll, llnode_t **node, void(*freeData)(void *))
llnode_t **	llNext (llnode_t **node)
llnode_t **	llFirst (linked_list_t *ll)
llnode_t **	llEnd (linked_list_t *ll)
void	llFree (linked_list_t *ll, void(*freeData)(void *))

Description détaillée

Fonctions de gestion de listes chainees.

Auteur

Fares BELHADJ amsi@.nosp@m.ai.u.nosp@m.niv-p.nosp@m.aris.nosp@m.8.fr

Date

January 16, 2006 - June 02, 2010 - February 22, 2016

A faire:

commenter

Définition dans le fichier linked_list.c.

Documentation des fonctions

llDelete()

void llDelete	(	linked_list_t *	ll,
		llnode_t **	node,
		void(*)(void *)	freeData
	)

                                                                              {
  llnode_t * todelete = *node;
  if(ll->tail == &((*node)->next))
    ll->tail = node;
  *node = (*node)->next;
  if(freeData)
    freeData(todelete->data);
  free(todelete);
}

Références llnode_t::data, llnode_t::next, et linked_list_t::tail.

Référencé par llPop().

llEmpty()

int llEmpty

(

linked_list_t *

ll

)

                                {
  return ll->tail == &(ll->head);
}

Références linked_list_t::head, et linked_list_t::tail.

Référencé par genId(), et gl4duClean().

llEnd()

llnode_t** llEnd

(

linked_list_t *

ll

)

                                      {
  return ll->tail;
}

Références linked_list_t::tail.

llFind()

pair_t llFind	(	linked_list_t *	ll,
		const void *	data,
		int(*)(const void *newData, const void *nodeData)	compar
	)

                                                                                                                 {
  pair_t res = {(void **)&(ll->head), -1};
  while(*(llnode_t **)res.ptr) {
    if((res.compResult = compar(data, (*(llnode_t **)res.ptr)->data)) <= 0)
      return res;
    else
      res.ptr = (void **)&((*(llnode_t **)res.ptr)->next);
  }
  return res;
}

Références pair_t::compResult, linked_list_t::head, et pair_t::ptr.

Référencé par llInsert().

llFirst()

llnode_t** llFirst

(

linked_list_t *

ll

)

                                        {
  return &(ll->head);
}

Références linked_list_t::head.

llFree()

void llFree	(	linked_list_t *	ll,
		void(*)(void *)	freeData
	)

                                                          {
  llnode_t * ptr = ll->head, * next;
  if(freeData)
    while(ptr) {
      next = ptr->next;
      freeData(ptr->data);
      free(ptr);
      ptr = next;
    }
  else
    while(ptr) {
      next = ptr->next;
      free(ptr);
      ptr = next;
    }
  free(ll);
}

Références llnode_t::data, linked_list_t::head, et llnode_t::next.

llInsert()

pair_t llInsert	(	linked_list_t *	ll,
		void *	data,
		int(*)(const void *newData, const void *nodeData)	compar
	)

                                                                                                             {
  pair_t res = llFind(ll, data, compar);
  if(res.compResult)
    llInsertAt((llnode_t **)res.ptr, data);
  return res;
}

Références pair_t::compResult, llFind(), llInsertAt(), et pair_t::ptr.

llInsertAt()

void llInsertAt	(	llnode_t **	here,
		void *	data
	)

                                               {
  llnode_t * next = *here;
  *here = malloc(sizeof ** here);
  assert(*here);
  (*here)->data = data;
  (*here)->next = next;
}

Référencé par llInsert().

llNew()

linked_list_t* llNew

(

void

)

                            {
  linked_list_t * ll = malloc(sizeof * ll);
  assert(ll);
  ll->head = NULL;
  ll->tail = &(ll->head);
  return ll;
}

Références linked_list_t::head, et linked_list_t::tail.

Référencé par gl4dgInit(), et gl4duAtExit().

llNext()

llnode_t** llNext

(

llnode_t **

node

)

                                     {
  return &((*node)->next);
}

llPop()

void* llPop

(

linked_list_t *

ll

)

                                 {
  void * data = ll->head->data;
  llDelete(ll, &(ll->head), NULL);
  return data;
}

Références llnode_t::data, linked_list_t::head, et llDelete().

Référencé par genId(), et gl4duClean().

llPush()

void llPush	(	linked_list_t *	ll,
		void *	data
	)

                                             {
  llnode_t * next = ll->head;
  ll->head = malloc(sizeof * ll->head);
  assert(ll->head);
  ll->head->data = data;
  ll->head->next = next;
  if(!next)
    ll->tail = &(ll->head->next);
}

Références llnode_t::data, linked_list_t::head, llnode_t::next, et linked_list_t::tail.

Référencé par genId(), gl4dgDelete(), gl4dgInit(), et gl4duAtExit().

llPushBack()

void llPushBack	(	linked_list_t *	ll,
		void *	data
	)

                                                 {
  *(ll->tail) = malloc(sizeof ** (ll->tail));
  assert(*(ll->tail));
  (*(ll->tail))->data = data;
  (*(ll->tail))->next = NULL;
  ll->tail = &((*(ll->tail))->next);
}

Références linked_list_t::tail.