Re: Visitor pattern vs if-ladder

Patricia Shanahan wrote:


This feels a bit like implementing one's own type system, something one
normally wants to avoid. The normal method is to use a marker interface
for different implementations with the same type:

class Car1 extends Vehicle implements Car {}
class Car2 extends Vehicle implements Car {}

gives the two implementations Car1 and Car2 the same type Car. However,
I don't see a good way to transform a type into a marker type. Anything
I can come up with seems pretty computationally intensive. If
performance is not a concern, that that's fine, but performance is
rarely of no concern. The "asSubclass() method of Class unfortunately
tends to return the same as Object.getClass() for marker types.

Once you get the marker type, then using your Map<T,Count> is easy.

Here's one idea:

package fubar;

public class SubClass
{
     public static <T> Class<? extends T> asSubclassOf( Class<T> type,
             Object o )
     {
         if( !type.isInstance( o ) ) {
             return null; // or throw exception
         }
         Class<?> classX = o.getClass();
         do {
             Class<?>[] interfaces = classX.getInterfaces();
             for( Class<?> c : interfaces ) {
                 Class<? extends T> subType = null;
                 try {
                     subType = c.asSubclass( type );
                 }
                 catch( ClassCastException x ) {
                     continue;
                 }
                 return subType;
             }
             classX = classX.getSuperclass();
         } while( classX != null );
         return null; // should never reach here
     }

     public static void main( String[] args )
     {
         Object[] test = {new Car1(), new Diesel(), new Car2(),
             "Bob", new Carx(),};

         for( Object o : test ) {
             System.out.println( "class: " + asSubclassOf(
                     VehicleMarker.class, o ) );
         }
     }
}

interface VehicleMarker{}
interface Car extends VehicleMarker{}
interface Moped extends VehicleMarker{}
interface Truck extends VehicleMarker{}

class Car1 implements Car{}
class Car2 implements Car{}
class Diesel implements Truck{}
class Car3 implements Car{}
class Carx extends Car3{}

Output:
run:
class: interface fubar.Car
class: interface fubar.Truck
class: interface fubar.Car
class: null
class: interface fubar.Car
BUILD SUCCESSFUL (total time: 2 seconds)