// Purpose.  Mediator
//
// Discussion.  On the left: Node objs  #include <iostream.h>
// interact directly with each other,
// recursion is required, removing a    class Node {
// Node is hard, and it is not possi-   public:
// ble to remove the first node.  On       Node( int v ) { val_ = v; }
// the right: a "mediating" List class     int getVal()  { return val_; }
// focuses and simplifies all the ad-   private:
// ministrative responsibilities, and      int  val_;
// the recursion (which does not scale  };
// up well) has been eliminated.
                                        class List {
#include <iostream.h>                   public:
                                           List() {
class Node {                                  for (int i=0; i < 10; i++)
public:                                          arr_[i] = 0;
   Node( int v, Node* n ) {                      num_ = 0;
      val_ = v;                            }
      next_ = n;                           void addNode( Node* n ) {
   }                                          arr_[num_++] = n;
   void traverse() {                       }
      cout << val_ << "  ";                void traverse() {
      if (next_)                              for (int i=0; i < num_; i++)
         next_->traverse();                      cout << arr_[i]->getVal()
      else                                          << "  ";
         cout << endl;                        cout << endl;
   }                                       }
   void removeNode( int v ) {              void removeNode( int v ) {
      Node*  ptr = (Node*) 1;                 int  i, j;
      removeNode_( v, &ptr );                 for (i=0; i < num_; i++)
   }                                             if (arr_[i]->getVal() == v)
private:                                         {
   int    val_;                                     for (j=i; j < num_; j++)
   Node*  next_;                                       arr_[j] = arr_[j+1];
   void removeNode_(int v, Node** n) {              num_--;
      if (val_ == v)                                break;
         *n = next_;                             }
      else                                 }
      {                                 private:
         next_->removeNode_( v, n );       Node*  arr_[10];
         if (*n != (Node*) 1)              int    num_;
         {                              };
            next_ = *n;
            *n = (Node*) 1;             void main( void )
         }                              {
      }                                    List  lst;
   }                                       Node  one( 11 ),  two( 22 );
};                                         Node  thr( 33 ),  fou( 44 );
                                           lst.addNode( &one );
void main( void )                          lst.addNode( &two );
{                                          lst.addNode( &thr );
   Node  fou( 44, 0 );                     lst.addNode( &fou );
   Node  thr( 33, &fou );                  lst.traverse();
   Node  two( 22, &thr );                  lst.removeNode( 44 );
   Node  one( 11, &two );                  lst.traverse();
   one.traverse();                         lst.removeNode( 11 );
   one.removeNode( 44 );                   lst.traverse();
   one.traverse();                      }
   one.removeNode( 22 );
   one.traverse();                      // 11  22  33  44
}                                       // 11  22  33
                                        // 22  33
// 11  22  33  44
// 11  22  33
// 11  33



// Purpose.  Mediator design pattern demo.
// 
// Discussion.  Though partitioning a system into many objects generally
// enhances reusability, proliferating interconnections tend to reduce it
// again.  You can avoid this problem by capsulating the interconnections
// (i.e. the collective behavior) in a separate "mediator" object.  A
// mediator is responsible for controlling and coordinating the
// interactions of a group of objects.  In this example, the dialog box
// object is functioning as the mediator.  Child widgets of the dialog box
// do not know, or care, who their siblings are.  Whenever a simulated
// user interaction occurs in a child widget [Widget::changed()], the
// widget does nothing except "delegate" that event to its parent dialog
// box [_mediator->widgetChanged( this )].
// FileSelectionDialog::widgetChanged() encapsulates all collective
// behavior for the dialog box (it serves as the hub of communication).
// The user may choose to "interact" with a simulated: filter edit field,
// directories list, files list, or selection edit field.

#include <iostream.h>

class FileSelectionDialog;

class Widget {
public:
	Widget( FileSelectionDialog* mediator, char* name ) {
		_mediator = mediator;
		strcpy( _name, name); }
	virtual void changed();
	virtual void updateWidget() = 0;
	virtual void queryWidget() = 0;
protected:
	char                 _name[20];
private:
	FileSelectionDialog* _mediator;
};

class List : public Widget {
public:
	List( FileSelectionDialog* dir, char* name ) : Widget( dir, name ) { }
    void queryWidget()  { cout << "   " << _name << " list queried" << endl; }
	void updateWidget() { cout << "   " << _name << " list updated" << endl; }
};

class Edit : public Widget {
public:
    Edit( FileSelectionDialog* dir, char* name ): Widget( dir, name ) { }
    void queryWidget()  { cout << "   " << _name << " edit queried" << endl; }
    void updateWidget() { cout << "   " << _name << " edit updated" << endl; }
};


class FileSelectionDialog {
public:
	enum Widgets { FilterEdit, DirList, FileList, SelectionEdit };
	FileSelectionDialog() {
		_components[FilterEdit]    = new Edit( this, "filter" );
		_components[DirList]       = new List( this, "dir" );
		_components[FileList]      = new List( this, "file" );
		_components[SelectionEdit] = new Edit( this, "selection" ); }
	virtual ~FileSelectionDialog();
	void handleEvent( int which ) {
		_components[which]->changed(); }
	virtual void widgetChanged( Widget* theChangedWidget ) {
		if (theChangedWidget == _components[FilterEdit] ) {
			_components[FilterEdit]->    queryWidget();
			_components[DirList]->       updateWidget();
			_components[FileList]->      updateWidget();
			_components[SelectionEdit]-> updateWidget(); }
		else if (theChangedWidget == _components[DirList] ) {
			_components[DirList]->       queryWidget();
			_components[FileList]->      updateWidget();
			_components[FilterEdit]->    updateWidget();
			_components[SelectionEdit]-> updateWidget(); }
		else if (theChangedWidget == _components[FileList] ) {
			_components[FileList]->      queryWidget();
 			_components[SelectionEdit]-> updateWidget(); }
		else if (theChangedWidget == _components[SelectionEdit] ) {
			_components[SelectionEdit]-> queryWidget();
			cout << "   file opened" << endl; } }
private:
	Widget* _components[4];
};

FileSelectionDialog::~FileSelectionDialog() {
	for (int i=0; i < 3; i++)
		delete _components[i]; }


void Widget::changed() {
	_mediator->widgetChanged( this ); }


void main() {
	FileSelectionDialog fileDialog;
	int                 i;

	cout << "Exit[0], Filter[1], Dir[2], File[3], Selection[4]: ";
	cin >> i;

	while (i)
	{
		fileDialog.handleEvent( i-1 );
		cout << "Exit[0], Filter[1], Dir[2], File[3], Selection[4]: ";
		cin >> i;
	}
}

// Exit[0], Filter[1], Dir[2], File[3], Selection[4]: 1
//    filter edit queried
//    dir list updated
//    file list updated
//    selection edit updated
// Exit[0], Filter[1], Dir[2], File[3], Selection[4]: 2
//    dir list queried
//    file list updated
//    filter edit updated
//    selection edit updated
// Exit[0], Filter[1], Dir[2], File[3], Selection[4]: 3
//    file list queried
//    selection edit updated
// Exit[0], Filter[1], Dir[2], File[3], Selection[4]: 4
//    selection edit queried
//    file opened
// Exit[0], Filter[1], Dir[2], File[3], Selection[4]: 3
//    file list queried
//    selection edit updated