Riferimenti per il file lista.c

#include "Include/lista.h"

Vai al codice sorgente di questo file.

Funzioni

void inizializza (struct lista *stack)
int ins_new_elem (channel_t sk_cl, struct lista *s)
channel_t estrazione (struct lista *s)
int delete_elem (const channel_t sk_cl, struct thread **pun)
int rimuovi (channel_t sk_cl, struct lista *s)
boolean full (const struct lista *s)
channel_t leggi_sk_cl (struct lista *s)

Descrizione dettagliata

Autore:
Tranchida Giulio, No. Matricola 241732
Si dichiara che il contenuto di questo file e', in ogni sua parte, opera originale dell'autore.

This program is free software; you can redistribuite it and/or modify it under the terms of the GNU/General Pubblic License as published the Free software Foundation; either version 2 of the License, or (at your opinion) any later version.

Definizione nel file lista.c.


Documentazione delle funzioni

void inizializza ( struct lista stack  ) 

inizializza

Funzione che inizializza lo stack

Parametri:
*stack 

Definizione alla linea 14 del file lista.c.

00014                                      {
00015         stack->num_threads=0;   /* azzeramento del contatore */
00016         stack->top_elem=NULL;   /* azzeramento del puntatore */
00017 }

int ins_new_elem ( channel_t  sk_cl,
struct lista stack 
)

ins_new_elem

Inserisce un elemento nello stack

Parametri:
sk_cl 
*stack 
Restituisce:
  • 0 in caso di successo
  • errno in caso di errore

Definizione alla linea 19 del file lista.c.

00019                                                   {
00020         struct thread *new = NULL;
00021 
00022         if (!(new = (struct thread *) malloc(sizeof(struct thread)))){
00023                 errore(__FILE__,__LINE__,
00024                 "Errore nel creare un nuovo elemento (STACK)",errno);
00025                 return errno;
00026         }
00027         new->sk_cl = sk_cl;
00028         new->next = s->top_elem;/* fa puntare il nuovo elemento al primo della lista */
00029         s->top_elem = new;              /* inserisce il nuovo elemento in testa alla lista */
00030         s->num_threads++;               /* incrementa il valore del contatore */
00031         return 0;
00032 }

channel_t estrazione ( struct lista stack  ) 

estrazione

Estrae l'elemento in cima allo stack

Parametri:
*stack 
Restituisce:
  • channel_t, l'identificatore del canale di comunicazione
  • -1 se l alista e' vuota

Definizione alla linea 34 del file lista.c.

00034                                      {
00035         int sk_cl = -1;
00036         /* Puntatore temporaneo che puntera'
00037          * all'area di memoria da eliminare */
00038         struct thread *tmp;
00039         
00040         /* Se la lista non e' vuota... */
00041         if (s->top_elem){
00042                 sk_cl = s->top_elem->sk_cl;
00043                 /* Ora tmp punta all'area di memoria dell'elemento in cima alla lista */        
00044                 tmp = s->top_elem;
00045                 /* Il secondo elemento della lista diventa il primo,
00046                  * vengono scambiati cioe' gli indirizzi */
00047                 s->top_elem = s->top_elem->next;
00048                 s->num_threads--;
00049                 free(tmp);
00050         }
00051         return sk_cl;
00052 }

int delete_elem ( const channel_t  sk_cl,
struct thread **  pun 
)

delete_elem

Funzione ricorsiva a solo uso interno, quindi non presente nell'header lista.h, richiamata esclusivamente dalla funzione rimuovi. Rimuove un elemento dall'albero, confrontandolo con il sk_cl passato.

Parametri:
pun puntatore all'indirizzo del puntatore dell'elemento da cancellare
sk_cl identificatore del socket, non modificabile
Valori di ritorno:
0 se tutto e' andato bene
-1 se l'elemento non e' presente

Definizione alla linea 67 del file lista.c.

00067                                                            {
00068         struct thread* nodo = *pun;
00069         int ret_val = 0;
00070         
00071         if (!nodo) return -1;
00072         if (nodo->sk_cl == sk_cl){
00073                 *pun = nodo->next;
00074                 free(nodo);
00075                 return 0;
00076         }
00077         else
00078                 ret_val = delete_elem(sk_cl, &(nodo->next));
00079 
00080         return ret_val;
00081 }

int rimuovi ( channel_t  sk_cl,
struct lista s 
)

rimuovi

Rimuove dalla lista un elemento con chiave "sk_cl" e lo disalloca.

Parametri:
s puntatore alla lista
sk_cl cidentificatore del canale di comunicazione
Restituisce:
0 se tutto e' andato bene -1 se l'elemento non e' presente

Definizione alla linea 83 del file lista.c.

00083                                              {
00084         int ret_val=0;
00085         
00086         if (s->top_elem){
00087                 /* Cerchiamo e rimuoviamo... */
00088                 ret_val = delete_elem(sk_cl, &(s->top_elem));
00089                 if (!ret_val) s->num_threads--;
00090                 return ret_val;
00091         }
00092         /* Altrimenti errore lista vuota... */
00093         return -1;
00094 }

boolean full ( const struct lista stack  ) 

full

Controlla se la coda e' piena o meno.

Parametri:
*stack 
Restituisce:
In accordo con il tipo "boolean" restituisce
  • true se piena
  • false altrimenti

Definizione alla linea 96 del file lista.c.

00096                                    {
00097         return ((boolean) (s->num_threads == FULL));
00098 }

channel_t leggi_sk_cl ( struct lista stack  ) 

leggi_sk_cl

Restituisce il l'id del socket dell'elemento in cima allo stack

Parametri:
*stack 
Restituisce:
channel_t, l'identificatore del canale di comunicazione tra client e server

Definizione alla linea 100 del file lista.c.

00100                                       {
00101         return s->top_elem->sk_cl;
00102 }

Generato il Fri Jan 28 22:16:29 2011 per SFAT: Simplified File Allocation Table Project da  doxygen 1.6.3