obserwator

#include <iostream>
#include <list>
#include <algorithm>
#include <string>
#include<fstream>

using namespace std;

struct STATE{
	string nazwa;
	string tekst;
};

class Observer;

class Subject
{
 public:
  Subject() {
   m_nSubjectState.nazwa="";
   m_nSubjectState.tekst="";
   }
  virtual ~Subject();

  void Notify();
  void Attach(Observer* pOberver);
  void Detach(Observer* pOberver);

  virtual void SetState(STATE nState);
  virtual STATE GetState();

 protected:
  STATE m_nSubjectState;
  std::list<Observer*> m_ListObserver;
};

class Observer
{
 public:
  Observer(){
  	m_nObserverState.nazwa="";
    m_nObserverState.tekst="";
   }


  virtual ~Observer() {}
  virtual void Update(Subject* pSubject) = 0;

 protected:
  STATE m_nObserverState;


};

class ConcreateSubject : public Subject
{
 public:
  ConcreateSubject() : Subject() {}
  virtual ~ConcreateSubject() {}

  virtual void SetState(STATE nState);
  virtual STATE GetState();
  void Update(Subject* pSubject);
};

class ConcreateObserver : public Observer
{
	private:
	string login;
    fstream plik;
 public:
  ConcreateObserver(string naz) : Observer() {
   	login=naz;
   	plik.open(naz+".txt",std::ios::out );


   }


  virtual ~ConcreateObserver() {
  }
  virtual void Update(Subject* pSubject);
};



void Subject::Attach(Observer* pObserver)
{
 std::cout << "Attach an Observer\n";
 m_ListObserver.push_back(pObserver);
}

void Subject::Detach(Observer* pOberver)
{
 std::list<Observer*>::iterator iter;
 iter = std::find(m_ListObserver.begin(),m_ListObserver.end(),pOberver);
 if (m_ListObserver.end() != iter)
 {
  m_ListObserver.erase(iter);
 }
 std::cout << "Detach an Observer\n";
}

void Subject::Notify()
{
 std::cout << "Notify Observer's State\n";
 std::list<Observer*>::iterator iter1,iter2;
 iter1 = m_ListObserver.begin();
 iter2 = m_ListObserver.end();
 for (;iter1 != iter2; ++iter1)
 {
  (*iter1)->Update(this);
 }
}

void Subject::SetState(STATE nState)
{
 std::cout << "SetState By Subject\n";
 m_nSubjectState = nState;
}

STATE Subject::GetState()
{
 std::cout << "GetState By Subject\n";
 return m_nSubjectState;
}

Subject::~Subject()
{
 std::list<Observer*>::iterator iter1,iter2,temp;
 iter1 = m_ListObserver.begin();
 iter2 = m_ListObserver.end();
 for (;iter1 != iter2;)
 {
  temp = iter1;
  ++iter1;
  delete(*temp);
 }
 m_ListObserver.clear();
}

void ConcreateSubject::SetState(STATE nState)
{
 std::cout << "SetState By ConcreateSubject\n";
 m_nSubjectState = nState;
}

STATE ConcreateSubject::GetState()
{
 std::cout << "GetState By ConcreateSubject\n";
 return m_nSubjectState;
}

void ConcreateObserver::Update(Subject* pSubject)
{
 if (NULL == pSubject)
 {
  return;
 }
 m_nObserverState = pSubject->GetState();
plik<<"Wiadomość:"+m_nObserverState.tekst+"  - wysłana przez:"<<m_nObserverState.nazwa<<endl;

// std::cout << "The ObserverState is " << m_nObserverState << std::endl;
}

int main()
{
 Observer *p1 = new ConcreateObserver("Mietek");
 Observer *p2 = new ConcreateObserver("Grzesiek");
 Observer *p3 = new ConcreateObserver("Szczepan");
// Observer *p2 = new ConcreateObserver;
 Subject* p = new ConcreateSubject;

 STATE st;
 st.nazwa="ktos";
 st.tekst="cos";
 STATE st1;
 st.nazwa="ktos2";
 st.tekst="cos2";

 p->Attach(p1);
 p->SetState(st);
 p->Notify();

 p->Notify();



 /*
 p->Attach(p2);
 p->SetState(st1);
 p->Notify();

 p->Detach(p1);
 p->Attach(p3);
 p->SetState(st);
 p->Notify();
 */

 /*
 p->Attach(p1);
 p->Attach(p2);
 p->SetState(4);
 p->Notify();
 p->Detach(p1);
 p->SetState(10);
 p->Notify();
 delete p;
 */

 return 0;
}