-
Notifications
You must be signed in to change notification settings - Fork 0
/
gestione_code.h
206 lines (183 loc) · 9.12 KB
/
gestione_code.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
#ifndef __GESTIONE_CODE__
#define __GESTIONE_CODE__
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>
#include "tipi_simulatore_societa.h"
/**
* La struttura dati utilizzata per rappresentare messaggi standard.
*/
typedef struct {
long mtype;
char mtext[256];
} msg;
/**
* La struttura dati utilizzata per rappresentare un individuo che si
* vuole accoppiare.
*/
typedef struct {
pid_t pid;
caratteristiche_individuo caratteristiche;
} individuo_per_accoppiamento;
/**
* La struttura dati utilizzata per rappresentare un messaggio di richiesta
* di accoppiamento.
*/
typedef struct {
long mtype;
individuo_per_accoppiamento individuo;
} msg_individuo;
/**
* La struttura dati utilizzata per rappresentare un messaggio di risposta ad
* una richiesta di accoppiamento.
*/
typedef struct {
long mtype;
bool esito;
} msg_esito_accoppiamento;
/**
* La struttura dati utilizzata per rappresentare le informazioni riguardanti
* un avvenuto accoppiamento.
*/
typedef struct {
char tipo_mittente;
pid_t pid_mittente;
pid_t pid_coniuge;
} informazioni_accoppiamento;
/**
* La struttura dati utilizzata per rappresentare un messaggio di notifica al
* gestore di un avvenuto accoppiamento da parte di un individuo A oppure B.
*/
typedef struct {
long mtype;
informazioni_accoppiamento informazioni;
} msg_notifica_accoppiamento;
/**
* Crea una nuova coda di messaggi utilizzando come chiave il parametro "chiave" e restituisce
* l'ID della coda appena creata.
* @param {int} chiave: la chiave utilizzata per la creazione della nuova coda
* @return {int}: ritorna l'ID della coda appena creata, in caso di errore durante la creazione
* chiude il programma
*/
int msg_crea_coda_messaggi(int chiave) ;
/**
* Recupera l'ID di una coda già creata dalla chiave del parametro "chiave" e ne restituisce
* l'ID.
* @param {int} chiave: la chiave di una coda già esistente
* @return {int}: ritorna l'ID della coda appena creata, in caso di errore durante il recupero
* chiude il programma
*/
int msg_recupera_coda(int chiave);
/**
* Manda un messaggio uguale al parametro "Messaggio" ad una coda con ID uguale al
* parametro "id" e di tipo uguale al parametro "tipo", in caso di errore durante
* l'invio il programma termina.
* @param {int} id: L'ID della coda su cui si vuole mandare il messaggio
* @param {char[]} messaggio: Una stringa che indica il messaggio che si vuole mandare
* @param {long} tipo: Un long che indica il tipo del messaggio che si vuole mandare
*/
void msg_manda_messaggio(int id, char messaggio [], long tipo);
/**
* Manda un messaggio con contenuto corrispondente al parametro "messaggio" ad una coda con ID
* uguale al parametro "id" e di tipo uguale al parametro "tipo", in caso di errore durante
* l'invio il programma termina.
* @param {int} id: L'ID della coda su cui si vuole mandare il messaggio
* @param {individuo_per_accoppiamento} messaggio: Una struct individuo_per_accoppiamento che
* indica il messaggio che si vuole mandare
* @param {long} tipo: Un long che indica il tipo del messaggio che si vuole mandare
*/
void msg_manda_messaggio_individuo(int id, individuo_per_accoppiamento messaggio, long tipo) ;
/**
* Manda un messaggio con contenuto corrispondente al parametro "esito_accoppiamento" ad una coda con ID
* uguale al parametro "id" e di tipo uguale al parametro "tipo", in caso di errore durante
* l'invio il programma termina.
* @param {int} id: L'ID della coda su cui si vuole mandare il messaggio
* @param {bool} esito_accoppiamento: valore di tipo bool che indica se l'accoppiamento è avvenuto
* oppure no, costituisce il contenuto del messaggio
* @param {long} tipo: Un long che indica il tipo del messaggio che si vuole mandare
*/
void msg_manda_messaggio_accoppiamento(int id, bool esito_accoppiamento, long tipo);
/**
* Manda un messaggio con contenuto corrispondente al parametro "informazioni" ad una coda con ID
* uguale al parametro "id", in caso di errore durante l'invio il programma termina.
* @param {int} id: L'ID della coda su cui si vuole mandare il messaggio
* @param {informazioni_accoppiamento} informazioni: contiene il pid, il tipo del processo chiamante
* e il pid del processo con il quale esso si è accoppiato.
*/
void msg_manda_messaggio_notifica_accoppiamento(int id, informazioni_accoppiamento informazioni);
/**
* Riceve un messaggio dalla coda con ID uguale al parametro "id" e di tipo uguale
* al parametro "tipo", la stringa del messaggio ricevuto viene copiato all'interno
* del parametro "messaggio_ricevuto", in caso di fallimento invece conclude il processo.
* @param {int} id: Un int che rappresenta l'ID della coda da cui si vuole ricevere il messaggio.
* @param {long} tipo: Un long che rappresenta il tipo del messaggio che si vuole ricevere.
* @param {char*} messaggio_ricevuto: Un puntatore a char che rappresenta la stringa ricevuta,
* inizialmente vuota.
*/
void msg_ricevi_messaggio(int id, long tipo, char* messaggio_ricevuto);
/**
* Riceve un messaggio dalla coda con ID uguale al parametro "id" e di tipo uguale
* al parametro "tipo", la struct del messaggio ricevuto viene copiata all'interno
* del parametro "messaggio_ricevuto", in caso di fallimento invece conclude il processo.
* @param {int} id: Un int che rappresenta l'ID della coda da cui si vuole ricevere il messaggio.
* @param {long} tipo: Un long che rappresenta il tipo del messaggio che si vuole ricevere.
* @param {individuo_per_accoppiamento} messaggio_ricevuto: Un puntatore individuo_per_accoppiamento
* che rappresenta le informazioni su un individuo ricevute, inizialmente nullo.
*/
void msg_ricevi_messaggio_individuo(int id, long tipo, individuo_per_accoppiamento* messaggio_ricevuto);
/**
* Riceve un messaggio dalla coda con ID uguale al parametro "id" e di tipo uguale
* al parametro "tipo", il valore contenuto nel campo esito del messaggio ricevuto viene
* copiato all'interno del parametro "messaggio_ricevuto", in caso di fallimento invece
* conclude il processo.
* @param {int} id: Un int che rappresenta l'ID della coda da cui si vuole ricevere il messaggio.
* @param {long} tipo: Un long che rappresenta il tipo del messaggio che si vuole ricevere.
* @param {bool*} messaggio_ricevuto: Un puntatore a bool che rappresenta la risposta alla richiesta
* di accoppiamento, inizialmente nullo.
*/
void msg_ricevi_messaggio_accoppiamento(int id, long tipo, bool* messaggio_ricevuto);
/**
* Riceve un messaggio dalla coda con ID uguale al parametro "id", le informazioni contenute nel
* messaggio vengono copiate all'interno del parametro "informazioni", in caso di fallimento
* invece conclude il processo.
* @param {int} id: Un int che rappresenta l'ID della coda da cui si vuole ricevere il messaggio.
* @param {informazioni_accoppiamento} informazioni: Un puntatore a informazioni_accoppiamento dove
* vengono inserite le informazioni sui processi che si sono accoppiati, inizialmente nullo.
*/
void msg_ricevi_messaggio_notifica_accoppiamento(int id, informazioni_accoppiamento* informazioni);
/**
* Riceve un messaggio dalla coda con ID uguale al parametro "id" e di tipo uguale
* al parametro "tipo", la stringa del messaggio ricevuto viene copiato all'interno
* del parametro "messaggio_ricevuto", in caso non ci siano messaggi non attende,
* in caso di fallimento invece conclude il processo.
* @param {int} id: Un int che rappresenta l'ID della coda da cui si vuole ricevere il messaggio.
* @param {long} tipo: Un long che rappresenta il tipo del messaggio che si vuole ricevere.
* @param {char*} messaggio_ricevuto: Un puntatore a char che rappresenta la stringa ricevuta,
* inizialmente vuota.
*/
void msg_ricevi_messaggio_nowait(int id, long tipo, char* messaggio_ricevuto);
/**
* Riceve un messaggio dalla coda con ID uguale al parametro "id" e di tipo uguale al parametro
* "tipo", la struct del messaggio ricevuto viene copiata all'interno del parametro
* "messaggio_ricevuto" e ritorna TRUE, se invece non ci sono messaggi con quel "tipo"
* ritorna FALSE, in caso di fallimento invece conclude il processo.
* @param {int} id: Un int che rappresenta l'ID della coda da cui si vuole ricevere il messaggio.
* @param {long} tipo: Un long che rappresenta il tipo del messaggio che si vuole ricevere.
* @param {individuo_per_accoppiamento} messaggio_ricevuto: Un puntatore individuo_per_accoppiamento
* che rappresenta le informazioni ricevute su un individuo, inizialmente nullo
* @return {bool}: ritorna TRUE in caso abbia trovato un messaggio con quel tipo sulla coda,
* FALSE altrimenti.
*/
bool msg_controlla_presenza_messaggi(int id, long tipo, individuo_per_accoppiamento* messaggio_ricevuto);
/**
* Rimuove la coda con ID uguale al paramentro "id", in caso di fallimento termina il processo.
* @param {int} id: Un intero che rappresenta l'ID della coda che si vuole rimuovere.
*/
void msg_rimuovi_coda(int id);
#endif