/** * Copyright (c) 2006 Michele Mastrogiovanni. * *   Licensed under the Apache License, Version 2.0 (the "License"); *   you may not use this file except in compliance with the License. *   You may obtain a copy of the License at * *       http://www.apache.org/licenses/LICENSE-2.0 * *   Unless required by applicable law or agreed to in writing, software *   distributed under the License is distributed on an "AS IS" BASIS, *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *   See the License for the specific language governing permissions and *   limitations under the License. * */ #ifndef _INITIALIZER_H_#define _INITIALIZER_H_#include <vector>////////////////////// Stato del nodo //////////////////////typedef enum {	INITIALIZER_STATUS_HELLO = 0x1,			// Il nodo sta ricevendo informazioni dai vicini.	INITIALIZER_STATUS_FIRST_DECISION = 0x2,  	// Il nodo si e' colorato la prima volta.	INITIALIZER_STATUS_LAST_DECISION = 0x3,  	// Il nodo si e' colorato l'ultima volta.	INITIALIZER_STATUS_END = 0x4				// Il nodo ha terminato l'algoritmo di colorazione.} InitializerStatus;//////////////////////// Tipi di messaggi ////////////////////////typedef enum{	INITIALIZER_NEIGHBORS = 0x0,			// Messaggio per comunicare la propria lista dei vicini.	INITIALIZER_COLOR = 0x1,				// Messaggio per comunicare il colore.	INITIALIZER_REQUEST = 0x2,				// Messaggio di richiesta di ritrasmissione.	INITIALIZER_DATA = 0x3					// Messaggio di dati.} InitializerMessageType;//////////////////////////// Header del pacchetto ////////////////////////////struct hdr_initializer {		InitializerMessageType msg_type;			// Tipo di messaggio.	InitializerStatus status;					// Stato del nodo all'invio del messaggio (usato per le ritrasmissioni).	NodeList * node_list;               // Lista dei vicini del mittente (solo per messaggio di tipo INITIALIZER_NEIGHBORS).	Color color;                        // Informazioni sul colore (messaggio INITIALIZER_COLOR).		////////////////////	// Accessibilita' //	////////////////////	static int offset_;	inline static int& offset() { return offset_; }	inline static hdr_initializer* access(const Packet* p) {		return (hdr_initializer*) p->access(offset_);	}};///////////// Timer /////////////class InitializerTimer;///////////// Agent /////////////class INITIALIZER_Agent : public ClusteringModule{public:		INITIALIZER_Agent();		// Funzione di ricezione dell'algoritmo di clustering.	virtual void receive(Packet * p, Handler * h);		// Fa partire il modulo.	virtual void startModule();		// Termine del lavoro del modulo.	virtual void endModule();			// Segnala lo scadere di un timeout per un messaggio.	void timeout(InitializerStatus type, NodeAddress from);		// Segnala il raggiungimento del massimo numero di timeout per un messaggio.	void lastTimeout(InitializerStatus type, NodeAddress from);		// Verifica che un pacchetto sia di tipo DATA.	virtual bool isDataPacket(Packet * p);		// Preparazione all'invio di un messaggio al layer inferiore	virtual void prepareSendDataDown(Packet * p);		protected:			Color firstColor;				// Primo colore del nodo (memorizzato per le ritrasmissioni).	Color lastColor;				// Ultimo colore del nodo (memorizzato per le ritrasmissioni).	InitializerStatus status;				// Stato dell'agente.	NodeColor firstColorNeighbors;	// Mappa del primo colore dei vicini.	NodeColor lastColorNeighbors;	// Mappa dell'ultimo colore dei vicini (e il clusterHead).	NodeNeighbors nodeNeighbors;	// Vicini dei vicini.	NodeNeighbors shortNeighbors;	// Vicini dei vicini che sono anche vicini del nodo. Il nodo escluso.	InitializerTimer * timer;				// Gestore dei timeout.	protected:			///////////////	// Procedure //	///////////////			// Gestione della fase di transisione da uno stato all'altro	void processStatus();			// Invia la propria lista dei vicini ad un nodo o a tutti.	void send_NEIGHBORS(NodeAddress to);		// Invia la segnalazione di colore (BIANCO o NERO) per una fase dell'algoritmo.	void send_COLOR(InitializerStatus status, NodeAddress to, Color color);		// Invia la richiesta di un certo messaggio ad un vicino.	void send_REQUEST(InitializerStatus message, NodeAddress to);		// Ricezione della lista dei vicini di un vicino.	void receive_NEIGHBORS(NodeAddress from, NodeList & neighbors);		// Ricezione del colore NERO di un vicino per una fase del protocollo.	void receive_COLOR(NodeAddress from, InitializerStatus status, Color color);		// Ricezione di una richiesta di ritrasmissione per un messaggio da parte di un vicino.	void receive_REQUEST(NodeAddress from, InitializerStatus message);		////////////////////	// Interrogazioni //	////////////////////		// Verifica se due vicini del nodo solo NON connessi.	bool twoNeighborsAreUnlinked();		// Verifica se il nodo passato come parametro copre tutti i vicini del nodo (REGOLA 1).	bool neighborsCoversMyNeighbors(NodeList & nodes);		// Verifica la REGOLA sulla base delle lunghezze specificate.	bool checkRule(int max);	bool neighborsConnected(NodeList & nodes);		// Crea un vettore di combinazioni.	void makeCombinations(NodeList & elements, Combinations & combinations, NodeList & lengths);		void printDecoloredMessage(NodeList & nodi);	// Restituisce il piu'grande vicino NERO.	NodeAddress greaterCluster();public:	static int degree;			// Variante degree.	static int stojmenovic;		// Variation Stojmenovic (no second communication phase).	static int _DEBUG_;	static int limit;	static double max_delay;	static int max_timeout_hello;	static double jitter_timeout_hello;	static double timeout_hello;	static int max_timeout_first_decision;	static double jitter_timeout_first_decision;	static double timeout_first_decision;	static int max_timeout_last_decision;	static double jitter_timeout_last_decision;	static double timeout_last_decision;};/////////////////////////////////// Timer per le ritrasmissioni ///////////////////////////////////class InitializerTimer: public Handler {public:		InitializerTimer(INITIALIZER_Agent * a) : Handler(), agent(a) {}		void handle(Event* e);		// Inizializza i timeout di un nodo	void initTimeouts(NodeList & neighbors);		// Lancia tutti i timeout per i messaggi HELLO.	void launchHelloTimeouts();		// Lancia tutti i timeout per i messaggi FIRST DECISION.	void launchFirstDecisionTimeouts();		// Lancia tutti i timeout per i messaggi SECOND DECISION.	void launchLastDecisionTimeouts();		// Viene segnalata la ricezione di un messaggio di HELLO: si elimina il timeout.	void receivedHello(NodeAddress from);		// Viene segnalata la ricezione di un messaggio di FIRST DECISION: si elimina il timeout.	void receivedFirstDecision(NodeAddress from);		// Viene segnalata la ricezione di un messaggio di SECOND DECISION: si elimina il timeout.	void receivedLastDecision(NodeAddress from);		// Verifica che il timeout sia per il messaggio di HELLO.	bool isHelloTimeout(Event * e);		// Verifica che il timeout sia per il messaggio di FIRST DECISION.	bool isFirstDecisionTimeout(Event * e);		// Verifica che il timeout sia per il messaggio di LAST DECISION.	bool isLastDecisionTimeout(Event * e);	protected:			// Timeout attivi per i messaggi HELLO.	TimeoutMap hello_timeouts;		// Timeout attivi per i messaggi FIRST DECISION.	TimeoutMap first_decision_timeouts;		// Timeout attivi per i messaggi LAST DECISION.	TimeoutMap last_decision_timeouts;		// Agente proprietario del Timer.	INITIALIZER_Agent * agent;};#endif