Observer Pattern

#include <list>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
 
// The Abstract Observer
class ObserverBoardInterface
{
public:
    virtual void update(float a,float b,float c) = 0;
};
 
// Abstract Interface for Displays
class DisplayBoardInterface
{
public:
    virtual void show() = 0;
};
 
// The Abstract Subject
class WeatherDataInterface
{
public:
    virtual void registerOb(ObserverBoardInterface* ob) = 0;
    virtual void removeOb(ObserverBoardInterface* ob) = 0;
    virtual void notifyOb() = 0;
};
 
// The Concrete Subject
class ParaWeatherData: public WeatherDataInterface
{
public:
    void SensorDataChange(float a,float b,float c)
    {
        m_humidity = a;
        m_temperature = b;
        m_pressure = c;
        notifyOb();
    }
 
    void registerOb(ObserverBoardInterface* ob)
    {
        m_obs.push_back(ob);
    }
 
    void removeOb(ObserverBoardInterface* ob)
    {
        m_obs.remove(ob);
    }
protected:
    void notifyOb()
    {
        list<ObserverBoardInterface*>::iterator pos = m_obs.begin();
        while (pos != m_obs.end())
        {
            ((ObserverBoardInterface* )(*pos))->update(m_humidity,m_temperature,m_pressure);
            (dynamic_cast<DisplayBoardInterface*>(*pos))->show();
            ++pos;
        }
    }
 
private:
    float        m_humidity;
    float        m_temperature;
    float        m_pressure;
    list<ObserverBoardInterface* > m_obs;
};
 
// A Concrete Observer
class CurrentConditionBoard : public ObserverBoardInterface, public DisplayBoardInterface
{
public:
    CurrentConditionBoard(ParaWeatherData& a):m_data(a)
    {
        m_data.registerOb(this);
    }
    void show()
    {
        cout<<"_____CurrentConditionBoard_____"<<endl;
        cout<<"humidity: "<<m_h<<endl;
        cout<<"temperature: "<<m_t<<endl;
        cout<<"pressure: "<<m_p<<endl;
        cout<<"_______________________________"<<endl;
    }
 
    void update(float h, float t, float p)
    {
        m_h = h;
        m_t = t;
        m_p = p;
    }
 
private:
    float m_h;
    float m_t;
    float m_p;
    ParaWeatherData& m_data;
};
 
// A Concrete Observer
class StatisticBoard : public ObserverBoardInterface, public DisplayBoardInterface
{
public:
    StatisticBoard(ParaWeatherData& a):m_maxt(-1000),m_mint(1000),m_avet(0),m_count(0),m_data(a)
    {
        m_data.registerOb(this);
    }
 
    void show()
    {
        cout<<"________StatisticBoard_________"<<endl;
        cout<<"lowest  temperature: "<<m_mint<<endl;
        cout<<"highest temperature: "<<m_maxt<<endl;
        cout<<"average temperature: "<<m_avet<<endl;
        cout<<"_______________________________"<<endl;
    }
 
    void update(float h, float t, float p)
    {
        ++m_count;
        if (t>m_maxt)
        {
            m_maxt = t;
        }
        if (t<m_mint)
        {
            m_mint = t;
        }
        m_avet = (m_avet * (m_count-1) + t)/m_count;
    }
 
private:
    float m_maxt;
    float  m_mint;
    float m_avet;
    int m_count;
    ParaWeatherData& m_data;
};
 
int main(int argc, char *argv[])
{
 
    ParaWeatherData * wdata = new ParaWeatherData;
    CurrentConditionBoard* currentB = new CurrentConditionBoard(*wdata);
    StatisticBoard* statisticB = new StatisticBoard(*wdata);
 
    wdata->SensorDataChange(10.2, 28.2, 1001);
    wdata->SensorDataChange(12, 30.12, 1003);
    wdata->SensorDataChange(10.2, 26, 806);
    wdata->SensorDataChange(10.3, 35.9, 900);
 
    wdata->removeOb(currentB);
 
    wdata->SensorDataChange(100, 40, 1900);  
 
    delete statisticB;
    delete currentB;
    delete wdata;
 
    return 0;
}

#include <map>
#include <string>
#include <list>
using namespace std;

// Abstract Observer
class ObserverLogInterface
{
	public:
		virtual void addMsg(char *msg) = 0;
		virtual int updateDB(); 
		virtual void setTerm(int) = 0;
		virtual int getTerm(int) = 0;
};
/*
 * Observer 구현
 * 이 구현은 pageview를 위한 알고리즘을 포함한다.
 */
class PageView : public ObserverLogInterface
{
	map<string pagename, int count> pageCount; 
	map<string pagename, int count>::iterator pos;
	int term;
	int alarmTime;
	public:
		void addMsg(char *msg)
		{
			string pagename;
			// 들어온 로그메시지를 파싱해서 페이지 이름을 얻어와서 counting 한다. 
			// 파싱했다고 가정하고		
			pos = pageCount.find(pagename);
			if(pos == pageCount.end())
			{
				pageCount[pagename] = 0;
			}
			else
			{
				pos->second++;
			}
		}

		int updateDB()
		{
			// {pagename, count}를 RRD(:12)에 저장한다.	
			// RRD 파일의 이름은 paganeme.rrd로 하겠다.
			// 그냥 구현했다고 가정
			cout << "update RRD" <<endl;
		}

		void setTerm(int aterm)
		{
			// update될 시간을 설정한다.
			// 현재 시간에 + aterm을 한다.
			term = aterm;
			alarmTime = term+time(NULL);
		}

		int getTerm()
		{
			return term;
		}

		int countDown()
		{
			// update 남은 시간을 계산한다.
			// 값이 0보다 작다면 subject는 updateDB를 수행하게 된다. 
			return alarmTime - time(NULL); 
		}
}; 

/*
 * Observer 구현
 * 이 구현은 유저 검색어 count를 위한 알고리즘을 포함한다. 
 * 테스트를 위한 Dummy Observer이다.
 */
class KeywordCount : public ObserverLogInterface
{
	public:
		void addMsg(char *msg)
		{
		}

		int updateDB()
		{
		}

		void setTerm(int aterm)
		{
			term = aterm;
			alarmTime = term+time(NULL);
		}

		int getTerm()
		{
			return term;
		}

		int countDown()
		{
			return alarmTime - time(NULL); 
		}
}; 

// The Abstract Subject
class LogAnalyInterface
{
	public:
		virtual void registerOb(ObserverLogInterface *ob)=0;
		virtual void removeOb(ObserverLogInterface *ob)=0;
		virtual void notifyOb() = 0;
};

/*
  Subject Class의 구현
 */
class LogAnaly : public LoganalyInterface
{
	private:
		list<ObserverLogInterface *ob> m_obs;

	public:
		void registerOb(ObserverLogInterface *ob)
		{
			m_obs.push_back(ob);
		}
		void removeOb(ObserverLogInterface *ob)
		{
			m_obs.remove(ob);
		}

		// 새로운 로그메시지가 들어왔을 때.
		void addMsg(char *msg)
		{
			notifyMsgOb(char *msg);
		}

		// update Time을 확인
		void checkUpdate()
		{
			notifyDbOb(char *msg);
		}

	protected:
		void notifyMsgOb(char *msg)
		{
			list<ObserverLogInterface *ob>::iterator pos=m_obs.begin();
			while(pos != m_obs.end())
			{
        ((ObserverLogInterface* )(*pos))->addMsg(msg);
				pos++;
			}
		}
		void notifyDbOb()
		{
			int term;
			list<ObserverLogInterface *ob>::iterator pos=m_obs.begin();
			while(pos != m_obs.end())
			{
				// 만약 update시간이 되었다면 updateDB 메서드를 실행시킨다.
				if( ((ObserverLogInterface* )(*pos))->countDown() < 0)
				{
					term = (ObserverLogInterface* )(*pos))->getTerm();
					(ObserverLogInterface* )(*pos))->updateDB();
					// alarm Time을 reset 한다.
					(ObserverLogInterface* )(*pos))->setTerm(term);
				}
				pos++;
			}
		}
};

int main()
{
	AccessLogAnaly = new LogAnlay; 
	AccessLogAnaly->registerOb(new PageView);
	AccessLogAnaly->registerOb(new KeywordCount);
	while(tail(logfile))
	{
		// tail함수를 이용해서 새로운 로그가 들어오면  
		// PageView와 keywordCount Observer에 메시지를 넘긴다.
		AccessLogAnaly->addMsg();

		// Update 시간을 체크한다.
		AccessLogAnaly->checkUpdate();
		sleep(1);
	}
}

class MyModule extends Module
{
	function model()
	{
		$domain = $this->options['d']; // 첫페이지 검색인지 전문검색인지에 대한 uri 인자값
		$this->registerView($this->viewFirstPage,'t');
		$this->registerView($this->viewSearchPage,'s');

		$this->runView($domain);
	}

	function viewFirstPage()
	{
		// 첫페이지 뷰
	}

	function viewSearchPage()
	{
		// 전문검색 페이지 뷰 
	}
}