/*******************************************************************
*
*  DESCRIPTION: class Coordinator
*
*  AUTHOR:    Amir Barylko & Jorge Beyoglonian 
*  Version 2: Daniel A. Rodriguez
*
*  EMAIL: mailto://amir@dc.uba.ar
*         mailto://jbeyoglo@dc.uba.ar
*         mailto://drodrigu@dc.uba.ar
*
*  DATE: 27/6/1998
*  DATE: 04/6/1999 (v2)
*
*******************************************************************/

#ifndef __COORDINATOR_H
#define __COORDINATOR_H

/** include files **/
#include "process.h"          // class Processor
#include <set>

/** forward declarations **/
class Coupled ;

/** declarations **/
class Coordinator: public Processor 
{
public:
	
	typedef map< ProcId, Time , less<ProcId> > DependentList;

	Coordinator( Coupled * ); //constructor

//	Coordinator &Initialize();

	Processor &receive( const InitMessage & ) ;

	Processor &receive( const InternalMessage & ) ;

	Processor &receive( const OutputMessage & ) ;

        Processor &receive( const DoneMessage & ) ;

	Processor &receive( const CollectMessage &) ;


// Rami:  keep to aviod compilation errors 
	Processor &receive( const ExternalMessage & ) ;
//

protected:
	Coordinator(const Coordinator & ) ;	// Copy constructor

	Coordinator& operator=(const Coordinator & )  ;	 // Assignment operator

	int operator==(const Coordinator & ) const ;	// Equality operator

	Processor &id( const ProcId &pid ) ;

	const ProcId &inminentChild() const
			{return inminent;}

	Coordinator &inminentChild( const ProcId & ) ;

	//Rami
	//ProcId parentId;
	
	typedef set<ProcId> ProcSet;
	ProcSet synchronizeList;
	
	DependentList dependents;	
	
	const int doneCount() const;
	Coordinator &doneCount(int);

	virtual Coordinator &sortExternalMessage(const ExternalMessage & msg);
	virtual Coordinator &sortOutputMessage(const OutputMessage & msg);

	virtual Time &calculateNextChange(const Time &time ) const;
	//

	int donecount;

// Rami: keep this to avoid any compilation errors
	long receivedX;
//************************************************

private:
	ProcId inminent ;

	Coordinator &recalcInminentChild() ;

};	// class Coordinator


inline 
Coordinator &Coordinator::doneCount(int d) 
{
	donecount = d;
	return *this;
}

inline 
const int Coordinator::doneCount() const {
	return donecount;
}

/** inline **/
inline
Coordinator &Coordinator::inminentChild( const ProcId &mid ) 
{
	inminent = mid ;
	return *this ;
}

#endif   //__COORDINATOR_H