#include <iostream>
#include <vector>
#include <string>
using namespace std;

/*--------------------------------------------------------*\
    
\*--------------------------------------------------------*/

class GenericCallback
{
  public:
    GenericCallback() { };
    virtual void operator()(void);
};

void GenericCallback::operator()(void)
{
  return;
}





class Demo
{
  public:
    Demo(int _a) : a(_a) { };
   
    void registerCallBack(GenericCallback* cb);
    void executeCallBacks();

  private:

    int                     a;      
    vector< GenericCallback* > callbacks;
    
};

void Demo::registerCallBack(GenericCallback* cb)
{
  callbacks.push_back(cb);
  return;
}

void Demo::executeCallBacks()
{
  vector< GenericCallback* >::iterator cb;
  for ( cb = callbacks.begin(); cb != callbacks.end(); cb++ )
    (*(*cb))();
  return;
}




class WasWildes
{
  public:
    WasWildes(string _text) : text(_text){ };
    const string& getText() const { return text; };
    
  private:
    string text;    
};

class WasWildesCallback : public GenericCallback
{
  public:
    WasWildesCallback(const WasWildes* _ww) : ww(_ww) { };
    void operator()(void);

  private:
    const WasWildes* ww;
};

void WasWildesCallback::operator()(void)
{
  cout << ww->getText() << endl;
  return;
}




int main()
{
  WasWildes foo("hello world");
  WasWildes bar("heiho ich bins");

  WasWildesCallback cbfoo(&foo);
  WasWildesCallback cbbar(&bar);

  Demo cbcontainer(10);


  cbcontainer.registerCallBack(&cbfoo);
  cbcontainer.registerCallBack(&cbbar);


  cbcontainer.executeCallBacks();
  
  return 0;
}