//////////////////////////////////////////////////////
//													//
//	Incremental Clock Syncronization.				//
//	236503(20)	Summer 2001							//
//	Advanced Programming Project.					//
//	Technion. Computer Science Department.			//
//													//
//	Written by:		Reitman Anna	<s0anna0r@t2>	//
//					Fidelman Greg	<sgregf@t2>		//
//	Supervisor:		Hagit Attya		<hagit@cs>		//
//					Saar Pilosof	<psaar@cs>		//
//													//
//////////////////////////////////////////////////////
// ProcessHolder.h

#ifndef _PROCESSHOLDER_H
#define _PROCESSHOLDER_H

#include <math.h>
#include <vector>
#include <utility>
#include "IncClockSynch.h"

struct Process;


class ProcessHolder {
public:
	class Iterator;

private:
	
	typedef std::vector<Process*>	ProcessVector;
	
	bool initProcessVector_();//used for TIME_PROC and GAP_TIME scenario
	bool initNewProcVector_();//used for NEW_TIME scenarios

///////////////////////////////////

	long		m_nProcNum; //total number of processes (includes new proc)

// for first two scenarios: GAP_TIME and TIME_PROC only
	long		m_nMinClock; //min initial clock value
	long		m_nMaxClock; //max initial clock value
	long		m_nPercentCorrectProc;	//percent of correct processes 
										//(with average clock value)
// for NEW_PROC scenario only:
	long		m_nClocksValue; //clock value of correct processes
	long		m_nNewProcClock; //clock value of new process

//////////////////////////////////
	long		m_nMsgPerSlot;//number of messages sended per time round(tick);
	SendMsgRule	m_eMsgRule;//rule of sending messages (RANDOM,SEQUENTIAL)




	ProcessVector	m_ProcVector;

public:
	//used for GAP_TIME and TIME_PROC scenarios
	ProcessHolder(	long nProcNum,
					long nMinClock,
					long nMaxClock,
					long nPercentCorrectProcs,
					long msgPerSlot,
					SendMsgRule msgRule );

	//used for NEW_PROC scenario
	ProcessHolder(	long nProcNum,
					long nClocksValue,
					long nNewProcClock,
					long msgPerSlot,
					SendMsgRule msgRule );
	
	~ProcessHolder();

	bool sendMessage(long fromID,long msg);
	bool broadcastMessage(long fromID,long msg);

	void incClocks();

	long halfProc() const { return ceil(m_nProcNum/2); }
	long NumOfProc() const { return m_nProcNum; }

	// return pair<HagitGap,STGap>
	std::pair<long,long> getGap() const;
	
	friend class Iterator;
	class Iterator {
		ProcessHolder*	m_ProcHolder; //cannot iterate over const class
		long			m_currProc;

	public:
		Iterator(ProcessHolder* ph):m_ProcHolder(ph),m_currProc(0){};
		~Iterator(){};

		Process* operator*(){ return m_ProcHolder->m_ProcVector[m_currProc]; };

		operator bool(){ return m_currProc < m_ProcHolder->m_nProcNum; };

		// Prefix ++.	++(++i) is legal (since returns a reference)
		Iterator& operator++(){ ++m_currProc; return *this; };
  
	};//of Iterator

};

#endif //_PROCESSHOLDER_H