// Purpose.  Visitor design pattern

// 1. Add an accept(Visitor) method to the "element" hierarchy
// 2. Create a "visitor" base class w/ a visit() method for every "element" type
// 3. Create a "visitor" derived class for each "operation" to do on "elements"
// 4. Client creates "visitor" objects and passes each to accept() calls

interface Element {
   public void accept( Visitor v ); // first dispatch     // 1. accept(Visitor)
}                                                         //    interface

class This implements Element {
   public void   accept( Visitor v ) { v.visit( this ); } // 1. accept(Visitor)
   public String thiss()             { return "This"; }   //    implementation
}

class That implements Element {
   public void   accept( Visitor v ) { v.visit( this ); }
   public String that()              { return "That"; }
}

class TheOther implements Element {
   public void   accept( Visitor v ) { v.visit( this ); }
   public String theOther()          { return "TheOther"; }
}

interface Visitor {                                    // 2. Create a "visitor"
   public void visit( This e ); ////// second dispatch //    base class with a
   public void visit( That e );                        //    visit() method for
   public void visit( TheOther e );                    //    every "element"
}                                                      //    type

class UpVisitor implements Visitor {                   // 3. Create a "visitor"
   public void visit( This e ) {                       //    derived class for
      System.out.println( "do Up on " + e.thiss() ); } //    each "operation"
   public void visit( That e ) {                       //    to perform on
      System.out.println( "do Up on " + e.that() ); }  //    "elements"
   public void visit( TheOther e ) {
      System.out.println( "do Up on " + e.theOther() ); }
}

class DownVisitor implements Visitor {
   public void visit( This e ) {
      System.out.println( "do Down on " + e.thiss() ); }
   public void visit( That e ) {
      System.out.println( "do Down on " + e.that() ); }
   public void visit( TheOther e ) {
      System.out.println( "do Down on " + e.theOther() ); }
}

class VisitorDemo {
   public static Element[] list = { new This(), new That(), new TheOther() };
   public static void main( String[] args ) {
      UpVisitor    up   = new UpVisitor();             // 4. Client creates
      DownVisitor  down = new DownVisitor();           //    "visitor" objects
      for (int i=0; i < list.length; i++)              //    and passes each
         list[i].accept( up );                         //    to accept() calls
      for (int i=0; i < list.length; i++)
         list[i].accept( down );
}  }

// do Up on This                // do Down on This
// do Up on That                // do Down on That
// do Up on TheOther            // do Down on TheOther


//===============================================================================

// Purpose.  Double dispatch (within a single hierarchy)
//
// Discussion.  We would like to declare a function like:
//    void process( virtual Base object1, virtual Base object2 )
// that does the right thing based on the type of 2 objects that come from
// a single inheritance hierarchy.  The only problem is that the keyword
// "virtual" may not be used to request dynamic binding for an object being
// passed as an argument.  Java will only "discriminate" the type of an object
// being messaged, not the type of an object being passed.  So in order for
// the type of 2 objects to be discriminated, each object must be the
// receiver of a virtual function call.  Here, when process1() is called on
// the first object, its type becomes "known" at runtime, but the type of
// the second is still UNknown.  process2() is then called on the second
// object, and the identity (and type) of the first object is passed as an
// argument.  Flow of control has now been vectored to the spot where the
// type (and identity) of both objects are known.

public class VisitorSingle {

interface Base {
   void process1( Base secondObject );
   void process2(  A   firstObject  );
   void process2(  B   firstObject  );
   void process2(  C   firstObject  );
}

static class A implements Base {
   public void process1( Base second ) { second.process2( this ); }
   public void process2( A first ) {
      System.out.println( "first is A, second is A" ); }
   public void process2( B first ) {
      System.out.println( "first is B, second is A" ); }
   public void process2( C first ) {
      System.out.println( "first is C, second is A" ); }
}

static class B implements Base {
   public void process1( Base second ) { second.process2( this ); }
   public void process2( A first ) {
      System.out.println( "first is A, second is B" ); }
   public void process2( B first ) {
      System.out.println( "first is B, second is B" ); }
   public void process2( C first ) {
      System.out.println( "first is C, second is B" ); }
}

static class C implements Base {
   public void process1( Base second ) { second.process2( this ); }
   public void process2( A first ) {
      System.out.println( "first is A, second is C" ); }
   public void process2( B first ) {
      System.out.println( "first is B, second is C" ); }
   public void process2( C first ) {
      System.out.println( "first is C, second is C" ); }
}

public static void main( String[] args ) {
   Base array[] = { new A(), new B(), new C() };
   for (int i=0; i < array.length; i++)
      for (int j=0; j < 3; j++)
         array[i].process1( array[j] );
}}

// first is A, second is A
// first is A, second is B
// first is A, second is C
// first is B, second is A
// first is B, second is B
// first is B, second is C
// first is C, second is A
// first is C, second is B
// first is C, second is C


//===============================================================================

// Purpose.  VisitorComposite1 is a basic Composite implementation with one
// recursive traversal method.  VisitorComposite2 is a non-Visitor implementation
// that models "parsing" the hierarchical Composite with the collect() recursive
// traversal method.  VisitorComposite3 is a Visitor implementation.
//
// Highlights.  VisitorComposite2 changes interface Component into an abstract
// class.  It requires protected static members.  VisitorComposite3 is "open for
// extension, but closed for modification".  The interface Component remains an
// interface.  Now that "collect" is an object, many of them can be created and
// can operate simultaneously (the previous static attributes would have required
// significant extra effort to provide this functionality).  Drawback: the public
// interface of Leaf and Composite had to be extended.

import java.util.*;

interface Component { void traverse(); }

class Leaf implements Component {
  private int number;
  public Leaf( int num ) { number = num; }
  public void traverse() { System.out.print( number + " " ); }
}

class Composite implements Component {
  private static char next = 'a';
  private List children = new ArrayList();
  private char letter = next++;

  public void add( Component c ) { children.add( c ); }
  public void traverse() {
    System.out.print( letter + " " );
    for (int i=0; i < children.size(); i++)
      ((Component)children.get(i)).traverse();
} }

public class VisitorComposite1 {
  public static void main( String[] args ) {
    Composite[] containers = new Composite[3];

    for (int i=0; i < containers.length; i++) {
      containers[i] = new Composite();
      for (int j=1; j < 4; j++)
        containers[i].add( new Leaf( i * containers.length + j ) );
    }

    for (int i=1; i < containers.length; i++)
      containers[0].add( containers[i] );

    containers[0].traverse();
    System.out.println();
} }

// a 1 2 3 b 4 5 6 c 7 8 9

//------------------------------ VisitorComposite2 ------------------------------

import java.util.*;

abstract class Component {
  protected static StringBuffer letters = new StringBuffer();
  protected static StringBuffer numbers = new StringBuffer();

  public abstract void traverse();
  public abstract void collect();
  public static String getLetters() { return letters.toString(); }
  public static String getNumbers() { return numbers.toString(); }
}

class Leaf extends Component {
  private int number;
  public Leaf( int num ) { number = num; }
  public void traverse() { System.out.print( number + " " ); }
  public void collect()  { numbers.append( number ); }
}

class Composite extends Component {
  private static char next = 'a';
  private List children = new ArrayList();
  private char letter = next++;

  public void add( Component c ) { children.add( c ); }
  public void traverse() {
    System.out.print( letter + " " );
    for (int i=0; i < children.size(); i++)
      ((Component)children.get(i)).traverse();
  }
  public void collect() {
    letters.append( letter );
    for (int i=0; i < children.size(); i++)
      ((Component)children.get(i)).collect();
} }

public class VisitorComposite2 {
  public static void main( String[] args ) {
    Composite[] containers = new Composite[3];

    for (int i=0; i < containers.length; i++) {
      containers[i] = new Composite();
      for (int j=1; j < 4; j++)
        containers[i].add( new Leaf( i * containers.length + j ) );
    }

    for (int i=1; i < containers.length; i++)
      containers[0].add( containers[i] );

    containers[0].traverse();
    System.out.println();

    containers[0].collect();
    System.out.print( "letters are - " + Component.getLetters() );
    System.out.println( ", numbers are - " + Component.getNumbers() );
} }

// a 1 2 3 b 4 5 6 c 7 8 9
// letters are - abc, numbers are - 123456789

//------------------------------ VisitorComposite3 ------------------------------

import java.util.*;

interface Component {
  void traverse();
  void accept( Visitor v );
}

class Leaf implements Component {
  private int number;
  public Leaf( int num )          { number = num; }
  public void traverse()          { System.out.print( number + " " ); }
  public void accept( Visitor v ) { v.visit( this ); }
  public int  getNumber()         { return number; }
}

class Composite implements Component {
  private static char next = 'a';
  private List children = new ArrayList();
  private char letter = next++;

  public void add( Component c ) { children.add( c ); }
  public void traverse() {
    System.out.print( letter + " " );
    for (int i=0; i < children.size(); i++)
      ((Component)children.get(i)).traverse();
  }
  public void accept( Visitor v ) {
    v.visit( this );
    for (int i=0; i < children.size(); i++)
      ((Component)children.get(i)).accept( v );
  }
  public char getLetter() { return letter; }
}

interface Visitor {
  void visit( Leaf l );
  void visit( Composite c );
}

class CollectVisitor implements Visitor {
  private StringBuffer letters = new StringBuffer();
  private StringBuffer numbers = new StringBuffer();

  public void   visit( Composite c ) { letters.append( c.getLetter() ); }
  public void   visit( Leaf l )      { numbers.append( l.getNumber() ); }
  public String getLetters()         { return letters.toString(); }
  public String getNumbers()         { return numbers.toString(); }
}

public class VisitorComposite3 {
  public static void main( String[] args ) {
    Composite[] containers = new Composite[3];

    for (int i=0; i < containers.length; i++) {
      containers[i] = new Composite();
      for (int j=1; j < 4; j++)
        containers[i].add( new Leaf( i * containers.length + j ) );
    }

    for (int i=1; i < containers.length; i++)
      containers[0].add( containers[i] );

    containers[0].traverse();
    System.out.println();

    CollectVisitor anOperation = new CollectVisitor();
    containers[0].accept( anOperation );
    System.out.print( "letters are - " + anOperation.getLetters() );
    System.out.println( ", numbers are - " + anOperation.getNumbers() );
} }

// a 1 2 3 b 4 5 6 c 7 8 9
// letters are - abc, numbers are - 123456789


//===============================================================================

// Problem.  "If you want to add a new Visitable object, you have to change
// the Visitor interface, and then implement that method in each of your
// Visitors."
//
// Solution.  With the ReflectiveVisitor, you only need one method in the
// Visitor interface - visit(Object).  All other visit() methods can be
// added later as point-to-point coupling is required.

import java.lang.reflect.Method;


////////// The "element" hierarchy //////////

interface Element {
   public void accept( ReflectiveVisitor v );
}
class This implements Element {
   public void   accept( ReflectiveVisitor v ) { v.visit( this ); }
   public String thiss()                       { return "This"; }
}
class That implements Element {
   public void   accept( ReflectiveVisitor v ) { v.visit( this ); }
   public String that()                        { return "That"; }
}
class TheOther implements Element {
   public void   accept( ReflectiveVisitor v ) { v.visit( this ); }
   public String theOther()                    { return "TheOther"; }
}


////////// The "operation" hierarchy //////////

abstract class ReflectiveVisitor {
  abstract public void visit( Object o );

  public void visitTheOther( TheOther e ) {
    System.out.println( "ReflectiveVisitor: do Base on " + e.theOther() );
  }

  // 1. Look for visitElementClassName() in the current class
  // 2. Look for visitElementClassName() in superclasses
  // 3. Look for visitElementClassName() in interfaces
  // 4. Look for visitObject() in current class
  protected Method getMethod( Class c ) {
    Class  newc = c;
    Method m    = null;
    while (m == null  &&  newc != Object.class) {
      String method = newc.getName();
      method = "visit" + method.substring( method.lastIndexOf('.') + 1 );
      try {
        m = getClass().getMethod( method, new Class[] { newc } );
      } catch (NoSuchMethodException ex) {
        newc = newc.getSuperclass();
    } }
    if (newc == Object.class) {
      // System.out.println( "Searching for interfaces" );
      Class[] interfaces = c.getInterfaces();
      for (int i=0; i < interfaces.length; i++) {
        String method = interfaces[i].getName();
        method = "visit" + method.substring( method.lastIndexOf('.') + 1 );
        try {
          m = getClass().getMethod( method, new Class[] { interfaces[i] } );
        } catch (NoSuchMethodException ex) { }
    } }
    if (m == null)
      try {
        m = getClass().getMethod( "visitObject", new Class[] { Object.class } );
      } catch (Exception ex) { }
    return m;
} }

class UpVisitor extends ReflectiveVisitor {
  public void visit( Object o ) {
    try {
      getMethod( o.getClass() ).invoke( this, new Object[] { o } );
    } catch (Exception ex) {
      System.out.println( "UpVisitor - no appropriate visit() method" );
  } }
  public void visitThis( This e ) {
    System.out.println( "UpVisitor: do Up on " + e.thiss() );
  }
  public void visitObject( Object e ) {
    System.out.println( "UpVisitor: generic visitObject() method" );
} }

class DownVisitor extends ReflectiveVisitor {
  public void visit( Object o ) {
    try {
      getMethod( o.getClass() ).invoke( this, new Object[] { o } );
    } catch (Exception ex) {
      System.out.println( "DownVisitor - no appropriate visit() method" );
  } }
  public void visitThat( That e ) {
    System.out.println( "DownVisitor: do Down on " + e.that() );
} }


class VisitorDemo {
  public static void main( String[] args ) {
    Element[]    list = { new This(), new That(), new TheOther() };
    UpVisitor    up   = new UpVisitor();
    DownVisitor  down = new DownVisitor();
    for (int i=0; i < list.length; i++)
      list[i].accept( up );
    for (int i=0; i < list.length; i++)
      list[i].accept( down );
} }

// UpVisitor: do Up on This
// UpVisitor: generic visitObject() method
// ReflectiveVisitor: do Base on TheOther
// DownVisitor - no appropriate visit() method
// DownVisitor: do Down on That
// ReflectiveVisitor: do Base on TheOther