[C-UNIX] Consiglio di implementazione...

[stella_650]

Ciao a tutti!
Avrei bisogno di un consiglio per l'implementazione di un problema relativo alla realizzazione di un progetto
io ho un modello client-server: un client scrive sulla socket una struct relativa ad un'ordinazione e la manda al server, questo server la legge e deve memorizzare questa struct da qualche parte...

Ora il consiglio che ora chiedo è proprio relativo a questa parte(colorata), cioè cercare di trovare una "struttura dati" che al meglio mi consenta di memorizzare quelle informazioni della struct, tenendo in considerazione le seguenti cose:
1.Man mano che si effettuano ordinazioni, in maniera sequenziale, le struct dovranno essere "accodate in memoria"
2.Tutto questo serve perchè devo fare in modo che una ricerca,per un particolare campo, cioè tavolo, mi prelevi alcune informazioni a me necessarie per gestire altre applicazioni.

La struct che deve essere letta e scritta su socket è:

struct info_client{
        char  pietanza[10];
        int   tavolo;
        int   portata;
}s;

P.S.: avevo pensato all'inizio tipo anche ad un file , come struttura di memorizzazione per l'intera struct ma non so, anche per il problema della ricerca, la vedevo una idea poco efficiente, per cui se conoscete un modo per gestire al meglio quanto ho esposto, ne sarei davvero grata!

Vi ringrazio a priori e spero di avere reply

[jappilas]

siccome mi pare di notare che si tratti di un sistema per ristoranti )(dove il numero di di tavoli non cambia più di tanto (a runtime), e siccome noto un disaccopiamento tra le transazioni e l' "in_memory model" dell' applicazione lato server
credo una soluzione potrebbe essere una semplice struttura hash - like composta in questo caso da un vettore, dimensionato sul numero di tavoli, in cui ogni elemento è un puntatore ad una struttura dati queue - la queue servirà per contenere e serializzare le transazioni pendenti , cioè le pietanze ordinate ma non ancora servite
ora, come realizzare una queue in C... se non ricordo male, con una struct contenente < dato , pointer all' elemento successivo > per ogni elemento, e
due puntatori esterni head e tail (rispettivamente al primo e all' ultimo elemento della coda ) puntatori che saranno in questo caso contenuti nella singola entry "tavolo" dell' array di cui sopra

quindi il tuo server quando riceverà l' ordinazione:
rileverà il tavolo a cui corrisponde,
malloc() -erà una nuova struct (),
la appenderà al puntatore "next" dell' oggetto attualmente in coda,
aggiornando di conseguenza il puntatore "tail" di Tables[currentTable]

certo, poi occorre implementare le funzioni di estrazione e inserimento nelle code, però le operazioni dovrebbero avvenire con complessità o(1)
e per ora ci si risparmia la serializzazione su file ... se serve ci si pensa in secondo tempo

tutto rigorosamente "se non sbaglio"

[stella_650]

humm mi servirebbe qualche dettaglio maggiore per l'aspetto implementativo, perchè onestamente neanche io ricordo come fare..,anche solo qualche dettaglio in più sulla struttura dati mi tornerebbe utile...grazie

[jappilas]

praticamente si tratta di una lista di elementi struct, solo con inserimento in coda e prelievo in testa
per semplificare parto dal presupposto che esaminare la prossima transazione in sospeso la "consumi" (solo insert / extract), ma puo' darsi a te serva una funzione a parte passa internamente al successivo fino a trovarne uno che rispetti qualche altro criterio di ricerca
in questo caso avresti accesso con complessita' costante sui tavoli e lineare, ad es, sul campo pietanza, a meno di non complicare la struttura dati con - ad es - un secondo vettore di indici

#include <string.h>

#define NUM_TAVOLI 25  //valore arbitrario

typedef struct {
        char  pietanza[10];
        int   tavolo;
        int   portata;
}info_client;

typedef struct {
    char pietanza[10];
    int portata;
    void * successivo;
}info_ordine;

typedef struct{
    info_ordine * primo;
    info_ordine *ultimo;
}info_tavolo;


info_tavolo vettore_tavoli[NUM_TAVOLI];

void inizializzazione_vettore(void){
    int i;
    i=0;
    for (i = 0 ; i < NUM_TAVOLI;i++){
        vettore_tavoli[i].primo = NULL;
        vettore_tavoli[i].ultimo = NULL;
   }
}

BOOL aggiunta_ordine_al_tavolo (info_client * cliente ) {
    
    int num_tavolo;
    info_ordine * ordine;

    num_tavolo= cliente->tavolo;
    ordine= malloc(sizeof(info_ordine));

    //se la creazione del nuovo elemento fallisce esco e ritorno false
    if(ordine==NULL)
        return FALSE;

    //salvo le informazioni sull' ordinazione preventivamente recuperate dal socket
    ordine->successivo = NULL;
    ordine->portata = cliente->portata;
    strcpy(ordine->pietanza, cliente->pietanza);

    //se entrambi i puntatori per il tavolo sono nulli, questo e' il primo oggetto inserito
    //quindi la coda lo vedrà sia come primo che come ultimo 
    if ((vettore_tavoli[num_tavolo].primo == NULL) && (vettore_tavoli[num_tavolo].ultimo == NULL)){
       vettore_tavoli[num_tavolo].primo = ordine;
       vettore_tavoli[num_tavolo].ultimo = ordine;
    }
    //altrimenti diventa il nuovo "ultimo"
    else {   
        vettore_tavoli[num_tavolo].ultimo->successivo = ordine;
        vettore_tavoli[num_tavolo].ultimo = ordine;
    }

    return TRUE;
}



//ritorno true se l' operazione riesce, false altrimenti 
BOOL prelievo_ordine_per_tavolo (int num_tavolo, info_ordine * ordine ) {

    info_ordine * nuovo_ordine_tavolo;
    info_ordine * ordine_tavolo = vettore_tavoli[num_tavolo].primo;      


    //se non c' e' un elemento di testa per la coda di questo tavolo, la ricerca fallisce
    if (ordine_tavolo == NULL) 
        return FALSE;

    //salvo il puntatore all' elemento ordinazione successivo nella coda, 
    //prima che venga perso eliminando l' oggetto corrente
    nuovo_ordine_tavolo = ordine_tavolo->successivo;        

    //recupero le informazioni sull' ordinazione
    ordine->portata = ordine_tavolo->portata;
    strcpy(ordine->pietanza, ordine_tavolo->pietanza); 
    
    //elimino l' oggetto corrente
    //notare che i due puntatori nel vettore_tavoli[..] restano temporaneamente appesi: 
    //verranno corretti subito dopo        
    free(ordine_tavolo);     
    
    //se i due puntatori erano uguali , vuol dire che quello estratto era l' unico elemento
    //devo reimpostare a NULL il puntatore all' oggetto finale della coda
    if (ordine_tavolo == vettore_tavoli[num_tavolo].ultimo) {
        vettore_tavoli[num_tavolo].ultimo = NULL;
    }
    
    //aggiorno la posizione di testa per il tavolo fin qui usato
    //se l' oggetto era l' unico, il suo campo "successivo" era già NULL 
    vettore_tavoli[num_tavolo].primo = nuovo_ordine_tavolo;
    
    return TRUE;
}

spero di non aver fatto "troppi" errori, lavorando su java ho il C un po' arrugginito
inoltre questo non è il mio solito modo di scrivere codice..

[stella_650]

wow secondo me sei stato più che gentile;
forse la mia richiesta poteva sembrare "eccessiva" e ti ringrazio per avermi aiutato.
Spero in questo modo di risolvere il problema.
Grazie ancora

[jappilas]

Originariamente inviato da stella_650

wow secondo me sei stato più che gentile;
forse la mia richiesta poteva sembrare "eccessiva" e ti ringrazio per avermi aiutato.
Spero in questo modo di risolvere il problema.
Grazie ancora

non c'è di che
non era per niente una richiesta eccessiva, anzi per studio o lavoro mi hanno chiesto cose molto peggiori
è che oltre ad essere lento a scrivere e un tantino distratto, nell' ultimo periodo mi ero abituato a scrivere codice puramente object oriented, in inglese e senza commenti

ps: ho fatto un po' di correzioni al codice in generale e una modifica alla seconda funzione per gestire un caso particolare, così dovrebbe andare meglio

[stella_650]

è che oltre ad essere lento a scrivere e un tantino distratto, nell' ultimo periodo mi ero abituato a scrivere codice puramente object oriented, in inglese e senza commenti

per questo allora è da apprezzare ancora di più
Grazie davvero