Encore des mutex, le début des threads aussi

Elevator/Elevator.c

@@ -5,37 +5,61 @@
 #include <string.h>
 #include "Elevator.h"
 
+SYNCHRONIZED_GETTER(Elevator, ELEVATOR_STATE, state)
+SYNCHRONIZED_SETTER(Elevator, ELEVATOR_STATE, state)
+
 void _free__Elevator(THIS(Elevator)){
 	DELETE(this->passenger_ids);
 	if (this->name != NULL)
 		free(this->name);
-	pthread_mutex_unlock(&this->passenger_mutex);
+
-	pthread_mutex_destroy(&this->passenger_mutex);
+	pthread_mutex_unlock(&this->mutex_passenger);
+	pthread_mutex_destroy(&this->mutex_passenger);
+
+	pthread_mutex_unlock(&this->mutex_state);
+	pthread_mutex_destroy(&this->mutex_state);
+
 	free(this);
 }
 
 int get_number_of_passengers_Elevator(THIS(Elevator)){
 	int num;
-	pthread_mutex_lock(&this->passenger_mutex);
+	pthread_mutex_lock(&this->mutex_passenger);
 	num = this->passenger_ids->get_size(this->passenger_ids);
-	pthread_mutex_lock(&this->passenger_mutex);
+	pthread_mutex_lock(&this->mutex_passenger);
 	return num;
 }
 
-int can_get_more_passengers_Elevator(_THIS(Elevator)){
+int can_get_more_passengers_Elevator(THIS(Elevator)){
 	return (this->get_number_of_passengers(this) < MAX_ELEVATOR_CAPACITY);
 }
 
+void repair_Elevator(THIS(Elevator)){
+	this->set_state(this, running);
+}
+
+void *runnable_Elevator(void * void_this){
+	/* This is where the thread logic will be implemented */
+	Elevator * this = (Elevator*) void_this;
+	/* Returning this to keep gcc and clang quiet while developing, will return NULL */
+	return this;
+}
+
 Elevator *_init_Elevator(char * name){
 	Elevator * new_elevator = malloc_or_die(sizeof(Elevator));
 	new_elevator->state = waiting;
 	new_elevator->name = strdup(name);
 	new_elevator->passenger_ids = NEW(List);
-	pthread_mutex_init(&new_elevator->passenger_mutex, NULL);
+	pthread_mutex_init(&new_elevator->mutex_passenger, NULL);
+	pthread_mutex_init(&new_elevator->mutex_state, NULL);
 
 	LINK_ALL(Elevator, new_elevator,
+			 runnable,
 			 get_number_of_passengers,
-			 can_get_more_passengers
+			 can_get_more_passengers,
+			 get_state,
+			 set_state,
+			 repair
 	);
 
 	return new_elevator;

Elevator/Elevator.h

@@ -11,17 +11,25 @@
 
 #define MAX_ELEVATOR_CAPACITY 10
 
-typedef enum {running, waiting, sleeping} ELEVATOR_STATE;
+typedef enum {running, waiting, sleeping, broken} ELEVATOR_STATE;
 
 typedef struct o_Elevator {
 	PRIVATE ELEVATOR_STATE state;
 	PRIVATE List * passenger_ids;
 	PRIVATE char * name;
-	PRIVATE pthread_mutex_t passenger_mutex;
+	PRIVATE pthread_mutex_t mutex_passenger;
+	PRIVATE pthread_mutex_t mutex_state;
 
+	PUBLIC void * (*runnable)(void * void_this);
+
+	SYNCHRONIZE PRIVATE void (*set_state)(_THIS(Elevator), ELEVATOR_STATE var);
+
+	SYNCHRONIZE PUBLIC void (*repair)(_THIS(Elevator));
 	SYNCHRONIZE PUBLIC int (*get_number_of_passengers)(_THIS(Elevator));
+	SYNCHRONIZE PUBLIC ELEVATOR_STATE (*get_state)(_THIS(Elevator));
 	SYNCHRONIZE PUBLIC int (*can_get_more_passengers)(_THIS(Elevator));
 	DESTRUCTOR(Elevator);
+
 } Elevator;
 
 FRIENDLY(state, Building)

Objects.h

@@ -29,6 +29,17 @@
 #define SETTER(obj_type, variable_type, variable) void set_##variable##_##obj_type(obj_type *this, variable_type var){\
 													this->variable = var; }
 
+#define SYNCHRONIZED_GETTER(obj_type, variable_type, variable) variable_type get_##variable##_##obj_type(obj_type *this){\
+														variable_type tmp_variable; \
+														pthread_mutex_lock(&this->mutex_##variable); \
+														tmp_variable = this->variable; \
+														pthread_mutex_unlock(&this->mutex_##variable); \
+														return tmp_variable; }
+#define SYNCHRONIZED_SETTER(obj_type, variable_type, variable) void set_##variable##_##obj_type(obj_type *this, variable_type var){\
+														pthread_mutex_lock(&this->mutex_##variable); \
+														this->variable = var; \
+														pthread_mutex_unlock(&this->mutex_##variable);}
+
 void * malloc_or_die(size_t size);
 
 /* Link all method from variadic list, support max 20 args */