Référence du fichier fixed_heap.h

gestion de tas d'éléments à taille fixe. Plus de détails...

#include "gl4du.h"

Graphe des dépendances par inclusion de fixed_heap.h:

Ce graphe montre quels fichiers incluent directement ou indirectement ce fichier :

Aller au code source de ce fichier.

Fonctions
GL4DAPI size_t GL4DAPIENTRY	fheapCreate (size_t nmem, size_t size)
	créé un tas de nmem éléments de taille size et retourne son id (<>0). Plus de détails...
GL4DAPI size_t GL4DAPIENTRY	fheapPut (size_t heap_id, void *element)
	insert, en copiant le contenu, un élément dans le tas et retourne son id (<>0). Plus de détails...
GL4DAPI void *GL4DAPIENTRY	fheapGet (size_t heap_id, size_t element_id)
	récupère un élément du tas et retourne le pointeur vers la donnée. Attention, cette fonction n'efface pas la donnée du tas. Plus de détails...
GL4DAPI void GL4DAPIENTRY	fheapDelete (size_t heap_id, size_t element_id)
	libère une donnée du tas (étiquette une donnée du tas comme espace libre). Plus de détails...
GL4DAPI void GL4DAPIENTRY	fheapDestroy (size_t heap_id)
	libère l'ensemble du tas et sa mémoire. Plus de détails...
GL4DAPI void GL4DAPIENTRY	fheapClean (void)
	libère tous les tas créés par cette bibliothèque. Plus de détails...

Description détaillée

gestion de tas d'éléments à taille fixe.

Auteur

Farès BELHADJ amsi@.nosp@m.ai.u.nosp@m.niv-p.nosp@m.aris.nosp@m.8.fr

Date

November 30, 2016

Définition dans le fichier fixed_heap.h.

Documentation des fonctions

fheapClean()

GL4DAPI void GL4DAPIENTRY fheapClean

(

void

)

libère tous les tas créés par cette bibliothèque.

                      {
  size_t i;
  fheap_t * h;
  if(!_heap.heap) return;
  for(i = 0; i < _heap.nmem; i++) {
    h = &(((fheap_t * )_heap.heap)[i]);
    if(h->heap)
      fheapDestroy(i + 1);
  }
  free(_heap.heap);
  _heap.heap = NULL;
  free(_heap.stack);
  _heap.stack = NULL;
  _heap.head = 0;
  _heap.size = 16;
}

Références _heap, fheapDestroy(), fheap_t::head, fheap_t::heap, fheap_t::nmem, fheap_t::size, et fheap_t::stack.

Référencé par fheapCreate().

fheapCreate()

GL4DAPI size_t GL4DAPIENTRY fheapCreate	(	size_t	nmem,
		size_t	size
	)

créé un tas de nmem éléments de taille size et retourne son id (<>0).

Paramètres

nmem	nombre initial d'éléments dans le tas.
size	taille, en octets, d'éléments du tas.

Renvoie

identifiant du tas créé (différent de 0).

                                             {
  fheap_t * h;
  size_t heap_id;
  static int ft = 1;
  if(_heap.heap == NULL) {
    _heap = _newheap(_heap.nmem, _heap.size);
    if(ft) gl4duAtExit(fheapClean);
    ft = 0;
  }
  heap_id = _pop(_heap.stack, &(_heap.head));
  if(_empty(_heap.head))
    _moreheap(&_heap);
  h = &(((fheap_t * )_heap.heap)[heap_id - 1]);
  *h =_newheap(nmem, size);
  return heap_id;
}

Références _empty(), _heap, _moreheap(), _newheap(), _pop(), fheapClean(), gl4duAtExit(), fheap_t::head, fheap_t::heap, fheap_t::nmem, fheap_t::size, et fheap_t::stack.

fheapDelete()

GL4DAPI void GL4DAPIENTRY fheapDelete	(	size_t	heap_id,
		size_t	element_id
	)

libère une donnée du tas (étiquette une donnée du tas comme espace libre).

Paramètres

heap_id	identifiant du tas duquel la donnée est libérée.
element_id	identifiant de la donnée à libérer.

                                                    {
  fheap_t * h = &(((fheap_t * )_heap.heap)[heap_id - 1]);
  _push(h->stack, &(h->head), --element_id);
}

Références _heap, _push(), fheap_t::head, fheap_t::heap, et fheap_t::stack.

fheapDestroy()

GL4DAPI void GL4DAPIENTRY fheapDestroy

(

size_t

heap_id

)

libère l'ensemble du tas et sa mémoire.

Paramètres

heap_id

identifiant du tas à libérer.

                                  {
  fheap_t * h = &(((fheap_t * )_heap.heap)[heap_id - 1]);
  free(h->heap); 
  h->heap = NULL;
  free(h->stack);
  h->stack = NULL;
  _push(_heap.stack, &(_heap.head), heap_id - 1);
}

Références _heap, _push(), fheap_t::head, fheap_t::heap, et fheap_t::stack.

Référencé par fheapClean().

fheapGet()

GL4DAPI void* GL4DAPIENTRY fheapGet	(	size_t	heap_id,
		size_t	element_id
	)

récupère un élément du tas et retourne le pointeur vers la donnée. Attention, cette fonction n'efface pas la donnée du tas.

Paramètres

heap_id	identifiant du tas duquel est extraite la donnée.
element_id	identifiant de la donnée à extraire.

Renvoie

pointeur vers la donnée extraite.

                                                   {
  fheap_t * h = &(((fheap_t * )_heap.heap)[heap_id - 1]);
  return &(h->heap[--element_id * h->size]);
}

Références _heap, fheap_t::heap, et fheap_t::size.

fheapPut()

GL4DAPI size_t GL4DAPIENTRY fheapPut	(	size_t	heap_id,
		void *	element
	)

insert, en copiant le contenu, un élément dans le tas et retourne son id (<>0).

Paramètres

heap_id	identifiant du tas dans lequel se passe l'insertion.
element	pointeur vers la donnée à insérer (copier).

Renvoie

identifiant de l'élément inséré dans le tas (différent de 0).

                                                {
  fheap_t * h = &(((fheap_t * )_heap.heap)[heap_id - 1]);
  size_t element_id = _pop(h->stack, &(h->head));
  if(_empty(h->head))
    _moreheap(h);
  memcpy(&(h->heap[(element_id - 1) * h->size]), element, h->size);
  return element_id;
}

Références _empty(), _heap, _moreheap(), _pop(), fheap_t::head, fheap_t::heap, fheap_t::size, et fheap_t::stack.