// Purpose.  Flyweight design pattern
//
// Discussion.  Trying to use objects at very low levels of granularity is 
// nice, but the overhead may be prohibitive.  Flyweight suggests removing the
// non-shareable state from the class, and having the client supply it when
// methods are called.  This places more responsibility on the client, but,
// considerably fewer instances of the Flyweight class are now created.
// Sharing of these instances is facilitated by introducing a Factory class
// that maintains a "cache" of existing Flyweights.

class Gazillion {
   private static int num = 0;
   private int        row, col;
   public Gazillion( int maxPerRow ) {
      row = num / maxPerRow;
      col = num % maxPerRow;
      num++;
   }
   void report() {
      System.out.print( " " + row + col );
}  }

public class FlyweightDemo {
   public static final int ROWS = 6, COLS = 10;

   public static void main( String[] args ) {
      Gazillion[][] matrix = new Gazillion[ROWS][COLS];
      for (int i=0; i < ROWS; i++)
         for (int j=0; j < COLS; j++)
            matrix[i][j] = new Gazillion( COLS );
      for (int i=0; i < ROWS; i++) {
         for (int j=0; j < COLS; j++)
            matrix[i][j].report();
         System.out.println();
}  }  }

// 00 01 02 03 04 05 06 07 08 09
// 10 11 12 13 14 15 16 17 18 19
// 20 21 22 23 24 25 26 27 28 29
// 30 31 32 33 34 35 36 37 38 39
// 40 41 42 43 44 45 46 47 48 49
// 50 51 52 53 54 55 56 57 58 59



// In this refactoring, the "row" state is considered shareable (within each
// row anyways), and the "col" state has been externalized (it is supplied by
// the client when report() is called).

class Gazillion {
   private int row;
   public Gazillion( int theRow ) {
      row = theRow;
      System.out.println( "ctor: " + row );
   }
   void report( int theCol ) {
      System.out.print( " " + row + theCol );
}  }

class Factory {
   private Gazillion[] pool;
   public Factory( int maxRows ) {
      pool = new Gazillion[maxRows];
   }
   public Gazillion getFlyweight( int theRow ) {
      if (pool[theRow] == null)
         pool[theRow] = new Gazillion( theRow );
      return pool[theRow];
}  }

public class FlyweightDemo {
   public static final int ROWS = 6, COLS = 10;

   public static void main( String[] args ) {
      Factory theFactory = new Factory( ROWS );
      for (int i=0; i < ROWS; i++) {
         for (int j=0; j < COLS; j++)
            theFactory.getFlyweight( i ).report( j );
         System.out.println();
}  }  }

// ctor: 0
//  00 01 02 03 04 05 06 07 08 09
// ctor: 1
//  10 11 12 13 14 15 16 17 18 19
// ctor: 2
//  20 21 22 23 24 25 26 27 28 29
// ctor: 3
//  30 31 32 33 34 35 36 37 38 39
// ctor: 4
//  40 41 42 43 44 45 46 47 48 49
// ctor: 5
//  50 51 52 53 54 55 56 57 58 59




// Purpose.  Flyweight design pattern

// 1. Identify shareable state (intrinsic) and non-shareable state (extrinsic)
// 2. Create a Factory that can return an existing object or a new object
// 3. The client must use the Factory instead of "new" to request objects
// 4. The client (or a third party) must provide/compute the extrinsic state

import java.awt.*;
import java.awt.event.*;

class FlyweightFactory {
   private static java.util.Map  ht = new java.util.TreeMap();
   private static int            sharedButtons = 0;
   private static ButtonListener bl = new ButtonListener();
   public static Button makeButton( String num ) {
      Button btn;
      if (ht.containsKey( num )) {
         // 1. Identify intrinsic state (Button label)
         // 2. Return an existing object   [The same Button cannot be added
         //    multiple times to a container, and, Buttons cannot be cloned.
         //    So - this is only simulating the sharing that the Flyweight
         //    pattern provides.]
         btn = new Button( ((Button)ht.get(num)).getLabel() );
         sharedButtons++;
      } else {
         // 2. Return a new object
         btn = new Button( num );
         ht.put( num, btn );
      }
      btn.addActionListener( bl );
      return btn;
   }
   public static void report() {
      System.out.print( "new Buttons - " + ht.size()
         + ", \"shared\" Buttons - " + sharedButtons + ", " );
      for (java.util.Iterator it = ht.keySet().iterator(); it.hasNext(); )
         System.out.print( it.next() + " " );
      System.out.println();
}  }

class ButtonListener implements ActionListener {
   public void actionPerformed( ActionEvent e) {
      Button      btn  = (Button) e.getSource();
      java.awt.Component[] btns = btn.getParent().getComponents();
      int i = 0;
      for ( ; i < btns.length; i++)
         if (btn == btns[i]) break;
      // 4. A third party must compute the extrinsic state (x and y)
      //    (the Button label is intrinsic state)
      System.out.println( "label-" + e.getActionCommand()
         + "  x-" + i/10   + "  y-" + i%10 );  // 1. Identify extrinsic state
}  }                                           //    (Button location)

public class FlyweightDemo {
   public static void main( String[] args ) {
      java.util.Random rn = new java.util.Random();
      Frame frame = new Frame( "Flyweight Demo" );
      frame.addWindowListener( new WindowAdapter() {
        public void windowClosing( WindowEvent e ) {
          System.exit( 0 );
      } } );
      frame.setLayout( new GridLayout( 10, 10 ) );
      // 1. Identify shareable and non-shareable state
      //    shareable - Button label, non-shareable - Button location
      for (int i=0; i < 10; i++)
         for (int j=0; j < 10; j++)
            // 3. The client must use the Factory to request objects
            frame.add( FlyweightFactory.makeButton( 
               Integer.toString( rn.nextInt(15) ) ) );
      frame.pack();
      frame.setVisible( true );
      FlyweightFactory.report();
}  }

// new Buttons - 15, "shared" Buttons - 85, 0 1 10 11 12 13 14 2 3 4 5 6 7 8 9
// label-0  x-1  y-1
// label-0  x-2  y-2
// label-0  x-6  y-5
// label-0  x-2  y-5
// label-0  x-9  y-0
// label-1  x-9  y-9
// label-1  x-2  y-8
// label-1  x-5  y-8
// label-1  x-3  y-1




// Purpose.  heavyweight ColorBoxes ==> ColorBox Flyweights and a Factory 
//          (1 thread per ColorBox)         of pooled HandlerThreads 
//
// Discussion.  Creating a thread for each ColorBox is a much more straight-
// forward approach, but it doesn't scale when dozens of ColorBoxes are
// created.  Sharing a "pool" of threads across the collection of ColorBoxes
// requires more thought to set-up, but does not saturate "system resources"
// like the former approach does.
//
// In the implementation below, each ColorBox "wraps" itself with a Thread
// object.  The Thread object provides all the "threading functionality magic"
// and simply calls ColorBox's run() method when it is promoted from the
// "ready" state to the "running" state.  When each Thread/ColorBox is swapped
// into the CPU, it causes the ColorBox part of itself to change its color and
// then graciously gives up the CPU [by calling sleep()] so that other Threads
// may run.
//
// In the ThreadPool implementation, after the ColorBoxes are set-up, the
// ThreadPool creates and starts 8 HandlerThreads.  When a HandlerThread is
// swapped into the CPU, it gets a random ColorBox object from ThreadPool's
// private Vector, tells the ColorBox to change its color, and graciously
// returns to the "asleep" state.
//
// "You can typically make your threaded applications run FASTER by inserting
// calls to sleep() (with reasonably long durations)."  This definitely contri-
// butes to the perception that Threads are a "black art".  Not enough calls:
// monopolization of the CPU.  Not enough duration: time expiration interrupt
// events interrupt the running thread before it can finish useful work.

import java.awt.*;

class ColorBox extends Canvas implements Runnable {
   private int    pause;
   private Color  curColor = getColor();
   private static Color[]  colors = { Color.black, Color.blue, Color.cyan,
      Color.darkGray, Color.gray, Color.green, Color.lightGray, Color.red,
      Color.magenta, Color.orange, Color.pink, Color.white, Color.yellow };

   public ColorBox( int p ) {
      pause = p;
      new Thread( this ).start();
   }
   private static Color getColor() {
      return colors[ (int)(Math.random() * 1000) % colors.length ];
   }
   public void run() {
      while (true) {
         curColor = getColor();
         repaint();
         try { Thread.sleep( pause ); } catch( InterruptedException e ) { }
   }  }
   public void paint( Graphics g ) {
      g.setColor( curColor );
      g.fillRect( 0, 0, getWidth(), getHeight() );
}  }

public class ColorBoxes {
   public static void main( String[] args ) {
      int size = 8, pause = 10;
      if (args.length > 0) size  = Integer.parseInt( args[0] );
      if (args.length > 1) pause = Integer.parseInt( args[1] );
      Frame f = new FrameClose( "ColorBoxes - 1 thread per ColorBox" );
      f.setLayout( new GridLayout( size, size ) );
      for (int i=0; i < size*size; i++) f.add( new ColorBox( pause ) );
      f.setSize( 500, 400 );
      f.setVisible( true );
}  }

// D:> java ColorBoxes 18 50
//         produces 324 boxes/threads and 50 millisecond sleep()



// Purpose.  8 shared HandlerThreads in a ThreadPool.  The ColorBox class
// has now become a Flyweight: the color changing and painting capability
// remains "intrinsic", and the threaded behavior has been made "extrinsic".
// The ThreadPool class plays the role of the Factory.  As ColorBox objects
// are created, they register themselves with the ThreadPool object.  The
// latter launches 8 "handler" threads.  When each thread is swapped into
// the CPU, it selects a random Flyweight from the ThreadPool's cache, and
// asks the object to changeColor().

import java.awt.*;
import java.util.Vector;

class ColorBox2 extends Canvas {
   private Color  curColor = getColor();
   private static Color[]  colors = { Color.black, Color.blue, Color.cyan,
      Color.darkGray, Color.gray, Color.green, Color.lightGray, Color.red,
      Color.magenta, Color.orange, Color.pink, Color.white, Color.yellow };

   public ColorBox2( ThreadPool2 tp ) {
      tp.register( this );
   }
   private static Color getColor() {
      return colors[ (int)(Math.random() * 1000) % colors.length ];
   }
   public void changeColor() {
      curColor = getColor();
      repaint();
   }
   public void paint( Graphics g ) {
      g.setColor( curColor );
      g.fillRect( 0, 0, getWidth(), getHeight() );
}  }

class ThreadPool2 {
   private final int NUM_THREADS = 8;
   private Vector cboxes = new Vector();
   private int    pause;

   class HandlerThread extends Thread {
      public void run() {
         while (true) {
            ((ColorBox2) cboxes.elementAt(
               (int)(Math.random()*1000) % cboxes.size() )).changeColor();
            try { Thread.sleep( pause ); } catch( InterruptedException e ) { }
   }  }  }

   public ThreadPool2( int p ) {
      pause = p;
   }
   public void register( ColorBox2 r ) {
      cboxes.addElement( r );
   }
   public void start() {
      for (int i=0; i < NUM_THREADS; i++) new HandlerThread().start();
}  }

public class ColorBoxes2 {
   public static void main( String[] args ) {
      int size = 8, pause = 10;
      if (args.length > 0) size  = Integer.parseInt( args[0] );
      if (args.length > 1) pause = Integer.parseInt( args[1] );

      ThreadPool2 tp = new ThreadPool2( pause );

      Frame f = new FrameClose( "ColorBoxes2 - 8 shared HandlerThreads" );
      f.setLayout( new GridLayout( size, size ) );
      for (int i=0; i < size*size; i++) 
         f.add( new ColorBox2( tp ) );
      f.setSize( 500, 400 );
      f.setVisible( true );
      tp.start();
}  }

// D:> java ColorBoxes 18 50
//         produces 324 boxes, 8 threads, and 50 millisecond sleep()
//             performance is very much improved