// Purpose.  Lots of client effort to manage a list of Processors

public class ChainBefore {

interface Image { String process(); }
static class IR implements Image { public String process() { return "IR"; } }
static class LS implements Image { public String process() { return "LS"; } }

static class Processor {
   private static java.util.Random rn = new java.util.Random();
   private static int nextId = 1;
   private int id = nextId++;
   public boolean handle( Image img ) {
      if (rn.nextInt(2) != 0) {
         System.out.println( "   Processor " + id + " is busy" );
         return false;
      }
      System.out.println( "Processor " + id + " - " + img.process() );
      return true;
}  }

public static void main( String[] args ) {
   Image[] input = { new IR(), new IR(), new LS(), new IR(), new LS(), new LS() };
   Processor[] procs = { new Processor(), new Processor(), new Processor() };
   for (int i=0, j; i < input.length; i++) {
      j = 0;
      while ( ! procs[j].handle( input[i] ))
         j = (j+1) % procs.length;
}  }}

// Processor 1 - IR
//    Processor 1 is busy
//    Processor 2 is busy
//    Processor 3 is busy
//    Processor 1 is busy
//    Processor 2 is busy
// Processor 3 - IR
//    Processor 1 is busy
// Processor 2 - LS
// Processor 1 - IR
// Processor 1 - LS
//    Processor 1 is busy
//    Processor 2 is busy
//    Processor 3 is busy
// Processor 1 - LS



// Purpose.  Chain of Responsibility design pattern

public class ChainAfter {

interface Image { String process(); }
static class IR implements Image { public String process() { return "IR"; } }
static class LS implements Image { public String process() { return "LS"; } }

static class Processor {
   private static java.util.Random rn = new java.util.Random();
   private static int nextId = 1;
   private int       id = nextId++;
   private Processor next;
   public void add( Processor nextP ) {
      if (next != null) next.add( nextP );
      else next = nextP;
   }
   public void wrapAround( Processor firstP ) {
      if (next != null) next.wrapAround( firstP );
      else next = firstP;
   }
   public void handle( Image img ) {
      if (rn.nextInt(2) != 0) {
         System.out.println( "   Processor " + id + " is busy" );
         next.handle( img );
      } else
         System.out.println( "Processor " + id + " - " + img.process() );
}  }

static public Processor setUp() {
   Processor root = new Processor();
   for (int i=0; i < 2; i++) root.add( new Processor() );
   root.wrapAround( root );
   return root;
}

public static void main( String[] args ) {
   Image[] input = { new IR(), new IR(), new LS(), new IR(), new LS(), new LS() };
   Processor chain = setUp();
   for (int i=0; i < input.length; i++)
      chain.handle( input[i] );
}}

//    Processor 1 is busy
//    Processor 2 is busy
//    Processor 3 is busy
// Processor 1 - IR
// Processor 1 - IR
//    Processor 1 is busy
// Processor 2 - LS
// Processor 1 - IR
//    Processor 1 is busy
//    Processor 2 is busy
// Processor 3 - LS
//    Processor 1 is busy
//    Processor 2 is busy
// Processor 3 - LS



// Purpose.  Chain of Responsibility design pattern

// 1. Put a "next" pointer in the base class
// 2. The "chain" method in the base class always delegates to the next object
// 3. If the derived classes cannot handle, they delegate to the base class

abstract class Component {
   private int       value;
   private Component next;             // 1. "next" pointer in the base class
   public Component( int v )              { this( v, null ); }
   public Component( int v, Component n ) { value = v;  next = n; }
   public void setNext( Component n )     { next = n; }
   public void traverse()                 { System.out.print( value + " " ); }
   // 2. The "chain" method in the base class always delegates to the next obj
   public void volunteer()                { next.volunteer(); }
}

class Primitive extends Component {
   public Primitive( int val )              { this( val, null ); }
   public Primitive( int val, Component n ) { super( val, n ); }
   public void volunteer() {
      super.traverse();
      // 3. Primitive objects don't handle volunteer requests 5 times out of 6
      if ((int)(Math.random()*100) % 6 != 0)
         // 3. Delegate to the base class
         super.volunteer();
}  }

class Composite extends Component {
   private Component[] children = new Component[9];
   private int         total    = 0;
   public Composite( int val )              { this( val, null ); }
   public Composite( int val, Component n ) { super( val, n ); }
   public void add( Component c )           { children[total++] = c; }
   public void traverse() {
      super.traverse();                              // 1
      for (int i=0; i < total; i++)                  // |
         children[i].traverse();                     // +-- 2
   }                                                 // |   |
   // 3. Composite objects never handle volunteer    // |   +-- 4 5
   public void volunteer() {            // requests  // |
      super.volunteer();                             // +-- 3
}  }                                                 // |   |
                                                     // |   +-- 6 7
public class ChainDemo {                             // |
   public static void main( String[] args ) {        // +-- 8 9
      Component seven = new Primitive( 7 );          // 
      Component six   = new Primitive( 6, seven );   // tra: 1 2 4 5 3 6 7 8 9
      Composite three = new Composite( 3, six );     // 4
      three.add( six );  three.add( seven );         // 4 5 6 7
      Component five  = new Primitive( 5, three );   // 4 5 6 7 8 9
      Component four  = new Primitive( 4, five );    // 4 5 6 7 8
      Composite two   = new Composite( 2, four );    // 4 5 6 7
      two.add( four );   two.add( five );            // 4 5 6 7 8 9 4 5 6 7
      Composite one   = new Composite( 1, two );     // 4
      Component nine  = new Primitive( 9, one );     // 4 5 6 7 8 9 4 5 6 7 8
      Component eight = new Primitive( 8, nine );
      one.add( two );  one.add( three );  one.add( eight );  one.add( nine );
      seven.setNext( eight );
      System.out.print( "tra: " );  one.traverse();  System.out.println();
      for (int i=0; i < 8; i++) {
         one.volunteer();  System.out.println();
}  }  }



// Purpose.  Chain of Responsibility - links bid on job, chain assigns job
//
// 1. Base class maintains a "next" pointer
// 2. Each "link" does its part to handle (and/or pass on) the request
// 3. Client "launches and leaves" each request with the chain
// 4. The current bid and bidder are maintained in chain static members
// 5. The last link in the chain assigns the job to the low bidder

public class ChainBidDemo {

   static class Link {
      private int  id;
      private Link next;                       // 1. "next" pointer

      private static int  theBid = 999;        // 4. Current bid and bidder
      private static Link bidder;

      public Link( int num ) {
         id = num;
      }
      public void addLast( Link l ) {
         if (next != null) next.addLast( l );  // 2. Handle and/or pass on
         else              next = l; 
      }
      public void bid() {
         int num = ((int)(Math.random() * 100)) % 9;
         System.out.print( id + "-" + num + "  " );
         if (num < theBid) {
            theBid = num;                      // 4. Current bid and bidder
            bidder = this;
         }
         if (next != null) next.bid();         // 2. Handle and/or pass on
         else              bidder.execute();   // 5. The last 1 assigns the job
      }
      public void execute() {
         System.out.println( id + " is executing" );
         theBid = 999;
   }  }

   static Link setUpChain() {
      Link first = new Link( 1 );
      for (int i=2; i < 7; i++)
         first.addLast( new Link( i ) );
      return first;
   }

   public static void main( String[] args ) {
      Link chain = setUpChain();
      for (int i=0; i < 10; i++)
         chain.bid();                          // 3. Client "launches & leaves"
}  }

// 1-1  2-6  3-0  4-3  5-1  6-0  3 is executing
// 1-1  2-1  3-1  4-0  5-7  6-1  4 is executing
// 1-0  2-1  3-0  4-6  5-1  6-2  1 is executing
// 1-6  2-3  3-8  4-0  5-1  6-4  4 is executing
// 1-8  2-0  3-5  4-8  5-4  6-2  2 is executing
// 1-1  2-0  3-8  4-8  5-7  6-0  2 is executing
// 1-1  2-1  3-3  4-1  5-6  6-2  1 is executing
// 1-2  2-1  3-0  4-3  5-6  6-8  3 is executing
// 1-7  2-5  3-4  4-2  5-1  6-2  5 is executing
// 1-3  2-6  3-7  4-7  5-6  6-0  6 is executing



// Purpose.  The number to be factored is passed through a chain of Factor-
// Elements until none of them is able to decompose the number any further.

import java.io.*;
public class ChainContrib {

static class Memento {
      private boolean[] done;
      private int       sp      = 0;
      private int[]     factors = new int[10];
   public Memento( int num )    { done = new boolean[num]; }
   public void add( int n )     { factors[sp++] = n; }
   public void setDone( int i ) { done[i] = true; }
   public boolean isDone() {
      for (int i=0; i < done.length; i++) if ( ! done[i]) return false;
      return true;
   }
   public String toString() {
      StringBuffer sb = new StringBuffer();
      for (int i=0; i < sp; i++) { sb.append( factors[i] );  sb.append( ' ' ); }
      sp = 0;
      for (int i=0; i < done.length; i++) done[i] = false;
      return sb.toString();
}  }

static class FactorElement {
      private        int           index, divisor;
      private        FactorElement next;
      private static Memento       mem;
   public FactorElement( int i, int d, FactorElement fe ) {
      index = i;   divisor = d;   next = fe;
   }
   public void   setNext( FactorElement fe ) { next = fe; }
   public String getResults()                { return mem.toString(); }
   public void getFactors( int[] num ) {
      if (num[0] % divisor == 0) {
         mem.add( divisor );
         num[0] = num[0] / divisor;
      } else
         mem.setDone( index );
      if ( ! mem.isDone())
         next.getFactors( num );
   }
   public static FactorElement setUp() {
      int[] divisors = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };
      int size = divisors.length;
      mem = new Memento( size );
      FactorElement last = new FactorElement( size-1, divisors[size-1], null );
      FactorElement current = last;
      for (int i=size-2; i > -1; i--)
         current = new FactorElement( i, divisors[i], current );
      last.setNext( current );
      return current;
}  }

public static void main( String[] args ) throws IOException {
   BufferedReader rdr = new BufferedReader( new InputStreamReader( System.in ));
   int[]          num = new int[1];
   String         str;
   FactorElement  root = FactorElement.setUp();
   while (true) {
      System.out.print( "Enter number: " );
      str = rdr.readLine();
      if (str.equals("0")) break;
      num[0] = Integer.parseInt( str );
      root.getFactors( num );
      System.out.println( "   " + root.getResults() + "- " + num[0] );
}  }}

// Enter number: 30
//    2 3 5 - 1
// Enter number: 31
//    31 - 1
// Enter number: 32
//    2 2 2 2 2 - 1
// Enter number: 127
//    - 127
// Enter number: 60
//    2 3 5 2 - 1
// Enter number: 180
//    2 3 5 2 3 - 1
// Enter number: 216
//    2 3 2 3 2 3 - 1
// Enter number: 2310
//    2 3 5 7 11 - 1
// Enter number: 4620
//    2 3 5 7 11 2 - 1
// Enter number: 13860
//    2 3 5 7 11 2 3 - 1
// Enter number: 0