// Purpose.  Flyweight                  #include <iostream.h>
//
// Discussion.  Trying to use objects   const int X = 6;
// at very low levels of granularity    const int Y = 10;
// is nice, but the overhead may be
// prohibitive.  Flyweight suggests     class Gazillion {
// removing the non-shareable state     public:
// from the class, and having the cli-     Gazillion( int in ) {
// ent supply it when methods are             val1_ = in;
// called.  This places more respon-          cout << "ctor: "<< val1_<<endl; }
// sibility on the client, but, con-       ~Gazillion() {
// siderably fewer instances of the           cout << val1_ << ' '; }
// Flyweight class are now created.        void report( int in ) {
// Sharing of these instances is fa-          cout << val1_ << in << ' '; }
// cilitated by introducing a Factory   private:
// class that maintains a "cache" of       int  val1_;
// existing Flyweights.                 };
//
// In this example, the "X" state is    class Factory {
// considered shareable (within each    public:
// row anyways), and the "Y" state has     static Gazillion* getFly(int in) {
// been externalized (it is supplied          if ( ! pool_[in])
// by the client when report() is                pool_[in] =
// called).                                              new Gazillion( in );
                                              return pool_[in];
#include <iostream.h>                      }
                                           static void cleanUp() {
const int X = 6;                              cout << "dtors: ";
const int Y = 10;                             for (int i=0; i < X; i++)
                                                 if (pool_[i])
class Gazillion {                                   delete pool_[i];
public:                                       cout << endl;
   Gazillion() {                           }
      val1_ = num_ / Y;                 private:
      val2_ = num_ % Y;                    static Gazillion*  pool_[X];
      num_++;                           };
   }
   void report() {                      Gazillion*  Factory::pool_[]  = {
      cout << val1_ << val2_ << ' ';                             0,0,0,0,0,0 };
   }
private:                                void main( void )
   int    val1_;                        {
   int    val2_;                           for (int i=0; i < X; i++)
   static int num_;                        {
};                                            for (int j=0; j < Y; j++)
                                                 Factory::getFly(i)->report(j);
int Gazillion::num_ = 0;                      cout << endl;
                                           }
void main( void )                          Factory::cleanUp();
{                                       }
   Gazillion  matrix[X][Y];
   for (int i=0; i < X; i++)            // ctor: 0
   {                                    // 00 01 02 03 04 05 06 07 08 09
      for (int j=0; j < Y; j++)         // ctor: 1
         matrix[i][j].report();         // 10 11 12 13 14 15 16 17 18 19
      cout << endl;                     // ctor: 2
   }                                    // 20 21 22 23 24 25 26 27 28 29
}                                       // ctor: 3
                                        // 30 31 32 33 34 35 36 37 38 39
// 00 01 02 03 04 05 06 07 08 09        // ctor: 4
// 10 11 12 13 14 15 16 17 18 19        // 40 41 42 43 44 45 46 47 48 49
// 20 21 22 23 24 25 26 27 28 29        // ctor: 5
// 30 31 32 33 34 35 36 37 38 39        // 50 51 52 53 54 55 56 57 58 59
// 40 41 42 43 44 45 46 47 48 49        // dtors: 0 1 2 3 4 5
// 50 51 52 53 54 55 56 57 58 59



// Purpose.  Flyweight design pattern demo.
// 
// Discussion.  Flyweight describes how to share objects, so that their
// use at fine granularities is not cost prohibitive.  A key concept is
// the distinction between "intrinsic" and "extrinsic" state.  Intrinsic
// state consists of information that is independent of the flyweight's
// context - information that is sharable (i.e. each Icon's name, width,
// and height).  It is stored in the flyweight (i.e. the Icon class).
// Extrinsic state cannot be shared, it depends on and varies with the
// flyweight's context (i.e. the x,y position that each Icon instance's
// upper left corner will be drawn at).  Extrinsic state is stored or
// computed by the client and is passed to the flyweight when an operation
// is invoked.  Clients should not instantiate Flyweights directly, they
// should obtain them exclusively from a FlyweightFactory object to ensure
// they are shared properly.

#include <iostream.h>
#include <string.h>

class Icon {
public:
	Icon( char* fileName ) {
		strcpy( _name, fileName );
		if ( ! strcmp(fileName, "go"))     { _width = 20;  _height = 20; }
		if ( ! strcmp(fileName, "stop"))   { _width = 40;  _height = 40; }
		if ( ! strcmp(fileName, "select")) { _width = 60;  _height = 60; }
		if ( ! strcmp(fileName, "undo"))   { _width = 30;  _height = 30; } }
	const char* getName() { return _name; }
	draw( int x, int y ) {
		cout << "   drawing " << _name << ": upper left (" << x << "," << y
		<< ") - lower right (" << x + _width << "," << y + _height << ")"
		<< endl; }
private:
	char  _name[20];
	int   _width;
	int   _height;
};


class FlyweightFactory {
public:
	static Icon* getIcon( char* name ) {
		for (int i=0; i < _numIcons; i++)
			if ( ! strcmp( name, _icons[i]->getName() ))
				return _icons[i];
		_icons[_numIcons] = new Icon( name );
		return _icons[_numIcons++]; }
	static void reportTheIcons() {
		cout << "Active Flyweights: ";
		for (int i=0; i < _numIcons; i++)
			cout << _icons[i]->getName() << " ";
		cout << endl; }
private:
	enum { MAX_ICONS = 5 };
	static int    _numIcons;
	static Icon*  _icons[MAX_ICONS];
};

int   FlyweightFactory::_numIcons = 0;
Icon* FlyweightFactory::_icons[];


class DialogBox {
public:
	DialogBox( int x, int y, int incr ) : _iconsOriginX(x), _iconsOriginY(y),
		_iconsXIncrement(incr) { }
	virtual void draw() = 0;
protected:
	Icon* _icons[3];
	int   _iconsOriginX;
	int   _iconsOriginY;
	int   _iconsXIncrement;
};

class FileSelection : public DialogBox {
public:
	FileSelection( Icon* first, Icon* second, Icon* third ) :
		DialogBox(100,100,100) {
		_icons[0] = first;
		_icons[1] = second;
		_icons[2] = third; }
	void draw() {
		cout << "drawing FileSelection:" << endl;
		for (int i=0; i < 3; i++)
			_icons[i]->draw( _iconsOriginX + (i * _iconsXIncrement),
				_iconsOriginY ); }
};

class CommitTransaction : public DialogBox {
public:
	CommitTransaction( Icon* first, Icon* second, Icon* third ) :
		DialogBox(150,150,150) {
		_icons[0] = first;
		_icons[1] = second;
		_icons[2] = third; }
	void draw() {
		cout << "drawing CommitTransaction:" << endl;
		for (int i=0; i < 3; i++)
			_icons[i]->draw( _iconsOriginX + (i * _iconsXIncrement),
				_iconsOriginY ); }
};


void main() {
	DialogBox* dialogs[2];
	dialogs[0] = new FileSelection(
		FlyweightFactory::getIcon("go"),
		FlyweightFactory::getIcon("stop"),
		FlyweightFactory::getIcon("select") );
	dialogs[1] = new CommitTransaction(
		FlyweightFactory::getIcon("select"),
		FlyweightFactory::getIcon("stop"),
		FlyweightFactory::getIcon("undo") );

	for (int i=0; i < 2; i++)
		dialogs[i]->draw();

	FlyweightFactory::reportTheIcons();
}

// drawing FileSelection:
//    drawing go: upper left (100,100) - lower right (120,120)
//    drawing stop: upper left (200,100) - lower right (240,140)
//    drawing select: upper left (300,100) - lower right (360,160)
// drawing CommitTransaction:
//    drawing select: upper left (150,150) - lower right (210,210)
//    drawing stop: upper left (300,150) - lower right (340,190)
//    drawing undo: upper left (450,150) - lower right (480,180)
// Active Flyweights: go stop select undo